@pezkuwi/util 14.0.1 → 14.0.4

package/cjs/memoize.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = memoize;
+const stringify_js_1 = require("./stringify.js");
+function defaultGetId() {
+    return 'none';
+}
+/**
+ * @name memoize
+ * @description Memomize the function with a specific instanceId
+ */
+function memoize(fn, { getInstanceId = defaultGetId } = {}) {
+    const cache = {};
+    const memoized = (...args) => {
+        const stringParams = (0, stringify_js_1.stringify)(args);
+        const instanceId = getInstanceId();
+        if (!cache[instanceId]) {
+            cache[instanceId] = {};
+        }
+        if (cache[instanceId][stringParams] === undefined) {
+            cache[instanceId][stringParams] = fn(...args);
+        }
+        return cache[instanceId][stringParams];
+    };
+    memoized.unmemoize = (...args) => {
+        const stringParams = (0, stringify_js_1.stringify)(args);
+        const instanceId = getInstanceId();
+        if (cache[instanceId]?.[stringParams] !== undefined) {
+            delete cache[instanceId][stringParams];
+        }
+    };
+    return memoized;
+}

package/cjs/nextTick.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name nextTick
+ * @description Defer the operation to the queue for evaluation on the next tick
+ */
+export declare function nextTick(onExec: () => unknown, onError?: (error: Error) => unknown): void;

package/cjs/nextTick.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextTick = nextTick;
+/**
+ * @name nextTick
+ * @description Defer the operation to the queue for evaluation on the next tick
+ */
+function nextTick(onExec, onError) {
+    // While Promise.resolve().then(...) would defer to the nextTick, this
+    // actually does not play as nicely in browsers like the setTimeout(...)
+    // approach. So the safer, though less optimal approach is the one taken here
+    setTimeout(() => {
+        Promise
+            .resolve()
+            .then(() => {
+            onExec();
+        })
+            .catch((error) => {
+            if (onError) {
+                onError(error);
+            }
+            else {
+                console.error(error);
+            }
+        });
+    }, 0);
+}

package/cjs/noop.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A sharable identity function. Returns the input as-is with no transformation applied.
+ */
+export declare function identity<T>(value: T): T;
+/**
+ * A sharable noop function. As the name suggests, does nothing
+ */
+export declare function noop(): void;

package/cjs/noop.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identity = identity;
+exports.noop = noop;
+/**
+ * A sharable identity function. Returns the input as-is with no transformation applied.
+ */
+function identity(value) {
+    return value;
+}
+/**
+ * A sharable noop function. As the name suggests, does nothing
+ */
+function noop() {
+    // noop
+}

package/{src/number/index.ts → cjs/number/index.d.ts}

@@ -1,9 +1,5 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Utility methods to convert to and from `number` values
  */
-
 export { numberToHex } from './toHex.js';
 export { numberToU8a } from './toU8a.js';

package/cjs/number/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberToU8a = exports.numberToHex = void 0;
+/**
+ * @summary Utility methods to convert to and from `number` values
+ */
+var toHex_js_1 = require("./toHex.js");
+Object.defineProperty(exports, "numberToHex", { enumerable: true, get: function () { return toHex_js_1.numberToHex; } });
+var toU8a_js_1 = require("./toU8a.js");
+Object.defineProperty(exports, "numberToU8a", { enumerable: true, get: function () { return toU8a_js_1.numberToU8a; } });

package/cjs/number/toHex.d.ts

@@ -0,0 +1,17 @@
+import type { HexString } from '../types.js';
+/**
+ * @name numberToHex
+ * @summary Creates a hex value from a number.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `0x` result. `number` input values return the actual bytes value converted to a `hex`. With `bitLength` set, it converts the number to the equivalent size.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { numberToHex } from '@polkadot/util';
+ *
+ * numberToHex(0x1234); // => '0x1234'
+ * numberToHex(0x1234, 32); // => 0x00001234
+ * ```
+ */
+export declare function numberToHex(value?: number | null, bitLength?: number): HexString;

package/cjs/number/toHex.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberToHex = numberToHex;
+const fixLength_js_1 = require("../hex/fixLength.js");
+/**
+ * @name numberToHex
+ * @summary Creates a hex value from a number.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `0x` result. `number` input values return the actual bytes value converted to a `hex`. With `bitLength` set, it converts the number to the equivalent size.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { numberToHex } from '@pezkuwi/util';
+ *
+ * numberToHex(0x1234); // => '0x1234'
+ * numberToHex(0x1234, 32); // => 0x00001234
+ * ```
+ */
+function numberToHex(value, bitLength = -1) {
+    const hex = (!value || Number.isNaN(value) ? 0 : value).toString(16);
+    return (0, fixLength_js_1.hexFixLength)(hex.length % 2 ? `0${hex}` : hex, bitLength, true);
+}

package/cjs/number/toU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name numberToU8a
+ * @summary Creates a Uint8Array object from a number.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `number` input values return the actual bytes value converted to a `Uint8Array`. With `bitLength`, it converts the value to the equivalent size.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { numberToU8a } from '@polkadot/util';
+ *
+ * numberToU8a(0x1234); // => [0x12, 0x34]
+ * ```
+ */
+export declare function numberToU8a(value?: number | null, bitLength?: number): Uint8Array;

package/cjs/number/toU8a.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberToU8a = numberToU8a;
+const toU8a_js_1 = require("../hex/toU8a.js");
+const toHex_js_1 = require("./toHex.js");
+/**
+ * @name numberToU8a
+ * @summary Creates a Uint8Array object from a number.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `number` input values return the actual bytes value converted to a `Uint8Array`. With `bitLength`, it converts the value to the equivalent size.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { numberToU8a } from '@pezkuwi/util';
+ *
+ * numberToU8a(0x1234); // => [0x12, 0x34]
+ * ```
+ */
+function numberToU8a(value, bitLength = -1) {
+    return (0, toU8a_js_1.hexToU8a)((0, toHex_js_1.numberToHex)(value, bitLength));
+}

package/cjs/object/clear.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name objectClear
+ * @summary Removes all the keys from the input object
+ */
+export declare function objectClear<T>(value: Record<string, T>): Record<string, T>;

package/cjs/object/clear.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectClear = objectClear;
+/**
+ * @name objectClear
+ * @summary Removes all the keys from the input object
+ */
+function objectClear(value) {
+    const keys = Object.keys(value);
+    for (let i = 0, count = keys.length; i < count; i++) {
+        delete value[keys[i]];
+    }
+    return value;
+}

package/cjs/object/copy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name objectCopy
+ * @summary Creates a shallow clone of the input object
+ */
+export declare function objectCopy<T extends object>(source: T): T;

package/cjs/object/copy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectCopy = objectCopy;
+const spread_js_1 = require("./spread.js");
+/**
+ * @name objectCopy
+ * @summary Creates a shallow clone of the input object
+ */
+function objectCopy(source) {
+    return (0, spread_js_1.objectSpread)({}, source);
+}

package/cjs/object/entries.d.ts

@@ -0,0 +1,9 @@
+type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+/**
+ * @name objectEntries
+ * @summary A version of Object.entries that is typed for TS
+ */
+export declare function objectEntries<T extends object>(obj: T): Entries<T>;
+export {};

package/cjs/object/entries.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectEntries = objectEntries;
+/**
+ * @name objectEntries
+ * @summary A version of Object.entries that is typed for TS
+ */
+function objectEntries(obj) {
+    return Object.entries(obj);
+}

package/{src/object/index.ts → cjs/object/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export { objectClear } from './clear.js';
 export { objectCopy } from './copy.js';
 export { objectEntries } from './entries.js';

package/cjs/object/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectValues = exports.objectSpread = exports.objectProperty = exports.objectProperties = exports.objectKeys = exports.objectEntries = exports.objectCopy = exports.objectClear = void 0;
+var clear_js_1 = require("./clear.js");
+Object.defineProperty(exports, "objectClear", { enumerable: true, get: function () { return clear_js_1.objectClear; } });
+var copy_js_1 = require("./copy.js");
+Object.defineProperty(exports, "objectCopy", { enumerable: true, get: function () { return copy_js_1.objectCopy; } });
+var entries_js_1 = require("./entries.js");
+Object.defineProperty(exports, "objectEntries", { enumerable: true, get: function () { return entries_js_1.objectEntries; } });
+var keys_js_1 = require("./keys.js");
+Object.defineProperty(exports, "objectKeys", { enumerable: true, get: function () { return keys_js_1.objectKeys; } });
+var property_js_1 = require("./property.js");
+Object.defineProperty(exports, "objectProperties", { enumerable: true, get: function () { return property_js_1.objectProperties; } });
+Object.defineProperty(exports, "objectProperty", { enumerable: true, get: function () { return property_js_1.objectProperty; } });
+var spread_js_1 = require("./spread.js");
+Object.defineProperty(exports, "objectSpread", { enumerable: true, get: function () { return spread_js_1.objectSpread; } });
+var values_js_1 = require("./values.js");
+Object.defineProperty(exports, "objectValues", { enumerable: true, get: function () { return values_js_1.objectValues; } });

package/cjs/object/keys.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name objectKeys
+ * @summary A version of Object.keys that is typed for TS
+ */
+export declare function objectKeys<T extends object, K extends Extract<keyof T, string>>(value: T): K[];

package/cjs/object/keys.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectKeys = objectKeys;
+/**
+ * @name objectKeys
+ * @summary A version of Object.keys that is typed for TS
+ */
+function objectKeys(value) {
+    return Object.keys(value);
+}

package/cjs/object/property.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @name objectProperty
+ * @summary Assign a get property on the input object
+ */
+export declare function objectProperty<S>(that: object, key: string, getter: (key: string, index: number, self: S) => unknown, getName?: (key: string, index: number) => string, index?: number): void;
+/**
+ * @name objectProperties
+ * @summary Assign get properties on the input object
+ */
+export declare function objectProperties<S>(that: object, keys: string[], getter: (key: string, index: number, self: S) => unknown, getName?: (key: string, index: number) => string): void;

package/cjs/object/property.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectProperty = objectProperty;
+exports.objectProperties = objectProperties;
+/**
+ * @name objectProperty
+ * @summary Assign a get property on the input object
+ */
+function objectProperty(that, key, getter, getName, index = 0) {
+    const name = getName
+        ? getName(key, index)
+        : key;
+    // There are 3 approaches here -
+    //  - Object.prototype.hasOwnProperty.call(that, key) - this only checks the current class, i.e
+    //    will retuirn false if the property is set in the parent class
+    //  - isUndefined(...) - this may yield a false positive when the property is there, but not set.
+    //    Additionally, on pre-defined getters it may make a call
+    //  - key in that - Does not need to be combined with either of the above and checks the full chain
+    if (!(name in that)) {
+        Object.defineProperty(that, name, {
+            enumerable: true,
+            // Unlike in lazy, we always call into the upper function, i.e. this method
+            // does not cache old values (it is expected to be used for dynamic values)
+            get: function () {
+                return getter(key, index, this);
+            }
+        });
+    }
+}
+/**
+ * @name objectProperties
+ * @summary Assign get properties on the input object
+ */
+function objectProperties(that, keys, getter, getName) {
+    for (let i = 0, count = keys.length; i < count; i++) {
+        objectProperty(that, keys[i], getter, getName, i);
+    }
+}

package/cjs/object/spread.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @name objectSpread
+ * @summary Concats all sources into the destination
+ * @description Spreads object properties while maintaining object integrity
+ */
+export declare function objectSpread<T extends object>(dest: object, ...sources: (object | undefined | null)[]): T;

package/cjs/object/spread.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectSpread = objectSpread;
+/**
+ * @name objectSpread
+ * @summary Concats all sources into the destination
+ * @description Spreads object properties while maintaining object integrity
+ */
+function objectSpread(dest, ...sources) {
+    const filterProps = new Set(['__proto__', 'constructor', 'prototype']);
+    for (let i = 0, count = sources.length; i < count; i++) {
+        const src = sources[i];
+        if (src) {
+            if (typeof src.entries === 'function') {
+                for (const [key, value] of src.entries()) {
+                    if (!filterProps.has(key)) {
+                        dest[key] = value;
+                    }
+                }
+            }
+            else {
+                // Create a clean copy of the source object
+                const sanitizedSrc = Object.create(null);
+                for (const [key, value] of Object.entries(src)) {
+                    if (!filterProps.has(key)) {
+                        sanitizedSrc[key] = value;
+                    }
+                }
+                Object.assign(dest, sanitizedSrc);
+            }
+        }
+    }
+    return dest;
+}

package/cjs/object/values.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name objectValues
+ * @summary A version of Object.values that is typed for TS
+ */
+export declare function objectValues<T extends object>(obj: T): T[keyof T][];

package/cjs/object/values.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectValues = objectValues;
+/**
+ * @name objectValues
+ * @summary A version of Object.values that is typed for TS
+ */
+function objectValues(obj) {
+    return Object.values(obj);
+}

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/packageDetect.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const x_textdecoder_1 = require("@pezkuwi/x-textdecoder");
+const x_textencoder_1 = require("@pezkuwi/x-textencoder");
+const detectPackage_js_1 = require("./detectPackage.js");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, detectPackage_js_1.detectPackage)(packageInfo_js_1.packageInfo, null, [x_textdecoder_1.packageInfo, x_textencoder_1.packageInfo]);

package/cjs/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@pezkuwi/util', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.1' };

package/cjs/promisify.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @name promisify
+ * @summary Wraps an async callback into a `Promise`
+ * @description
+ * Wraps the supplied async function `fn` that has a standard JS callback `(error: Error, result: any)` into a `Promise`, passing the supplied parameters. When `error` is set, the Promise is rejected, else the Promise resolves with the `result` value.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * const { promisify } from '@polkadot/util';
+ *
+ * await promisify(null, ((a, cb) => cb(null, a), true); // resolves with `true`
+ * await promisify(null, (cb) => cb(new Error('error!'))); // rejects with `error!`
+ * ```
+ */
+export declare function promisify<R = any>(self: unknown, fn: (...params: any[]) => any, ...params: any[]): Promise<R>;

package/{src/promisify.ts → cjs/promisify.js}

@@ -1,6 +1,6 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promisify = promisify;
 /**
  * @name promisify
  * @summary Wraps an async callback into a `Promise`
@@ -16,15 +16,15 @@
  * await promisify(null, (cb) => cb(new Error('error!'))); // rejects with `error!`
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function promisify <R = any> (self: unknown, fn: (...params: any[]) => any, ...params: any[]): Promise<R> {
-  return new Promise((resolve, reject): void => {
-    fn.apply(self, params.concat((error: Error | null, result?: R): void => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(result as R);
-      }
-    }));
-  });
+function promisify(self, fn, ...params) {
+    return new Promise((resolve, reject) => {
+        fn.apply(self, params.concat((error, result) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(result);
+            }
+        }));
+    });
 }

package/cjs/string/camelCase.d.ts

@@ -0,0 +1,13 @@
+import type { AnyString } from '../types.js';
+export declare const CC_TO_UP: string[];
+export declare const CC_TO_LO: string[];
+/**
+ * @name stringCamelCase
+ * @summary Convert a dash/dot/underscore/space separated Ascii string/String to camelCase
+ */
+export declare const stringCamelCase: (value: AnyString) => string;
+/**
+ * @name stringPascalCase
+ * @summary Convert a dash/dot/underscore/space separated Ascii string/String to PascalCase
+ */
+export declare const stringPascalCase: (value: AnyString) => string;

package/cjs/string/camelCase.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringPascalCase = exports.stringCamelCase = exports.CC_TO_LO = exports.CC_TO_UP = void 0;
+exports.CC_TO_UP = new Array(256);
+exports.CC_TO_LO = new Array(256);
+for (let i = 0, count = exports.CC_TO_UP.length; i < count; i++) {
+    exports.CC_TO_LO[i] = String.fromCharCode(i).toLowerCase();
+    exports.CC_TO_UP[i] = String.fromCharCode(i).toUpperCase();
+}
+/** @internal */
+function formatAllCaps(w) {
+    return w.slice(0, w.length - 1).toLowerCase() + exports.CC_TO_UP[w.charCodeAt(w.length - 1)];
+}
+/**
+ * @internal
+ *
+ * Inspired by https://stackoverflow.com/a/2970667
+ *
+ * This is not as optimal as the original SO answer (we split into per-word),
+ * however it does pass the tests (which the SO version doesn't) and is still
+ * a major improvement over the original camelcase npm package -
+ *
+ *   camelcase: 20.88 μs/op
+ *        this:  1.00 μs/op
+ *
+ * Caveat of this: only Ascii, but acceptable for the intended usecase
+ */
+function converter(format) {
+    return (value) => {
+        const parts = value
+            // replace all separators (including consequtive) with spaces
+            .replace(/[-_., ]+/g, ' ')
+            // we don't want leading or trailing spaces
+            .trim()
+            // split into words
+            .split(' ');
+        let result = '';
+        for (let i = 0, count = parts.length; i < count; i++) {
+            const w = parts[i];
+            // apply the formatting
+            result += format(/^[\dA-Z]+$/.test(w)
+                // all full uppercase + letters are changed to lowercase
+                ? w.toLowerCase()
+                // all consecutive capitals + letters are changed to lowercase
+                // e.g. UUID64 -> uuid64, while preserving splits, eg. NFTOrder -> nftOrder
+                : w.replace(/^[\dA-Z]{2,}[^a-z]/, formatAllCaps), i);
+        }
+        return result;
+    };
+}
+/**
+ * @name stringCamelCase
+ * @summary Convert a dash/dot/underscore/space separated Ascii string/String to camelCase
+ */
+exports.stringCamelCase = converter((w, i) => 
+(i ? exports.CC_TO_UP[w.charCodeAt(0)] : exports.CC_TO_LO[w.charCodeAt(0)]) + w.slice(1));
+/**
+ * @name stringPascalCase
+ * @summary Convert a dash/dot/underscore/space separated Ascii string/String to PascalCase
+ */
+exports.stringPascalCase = converter((w) => 
+exports.CC_TO_UP[w.charCodeAt(0)] + w.slice(1));

package/{src/string/index.ts → cjs/string/index.d.ts}

@@ -1,10 +1,6 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Utility methods to convert to work with `string` values
  */
-
 export { stringCamelCase, stringPascalCase } from './camelCase.js';
 export { stringLowerFirst, stringUpperFirst } from './lowerFirst.js';
 export { stringShorten } from './shorten.js';

package/cjs/string/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToU8a = exports.stringToHex = exports.stringShorten = exports.stringUpperFirst = exports.stringLowerFirst = exports.stringPascalCase = exports.stringCamelCase = void 0;
+/**
+ * @summary Utility methods to convert to work with `string` values
+ */
+var camelCase_js_1 = require("./camelCase.js");
+Object.defineProperty(exports, "stringCamelCase", { enumerable: true, get: function () { return camelCase_js_1.stringCamelCase; } });
+Object.defineProperty(exports, "stringPascalCase", { enumerable: true, get: function () { return camelCase_js_1.stringPascalCase; } });
+var lowerFirst_js_1 = require("./lowerFirst.js");
+Object.defineProperty(exports, "stringLowerFirst", { enumerable: true, get: function () { return lowerFirst_js_1.stringLowerFirst; } });
+Object.defineProperty(exports, "stringUpperFirst", { enumerable: true, get: function () { return lowerFirst_js_1.stringUpperFirst; } });
+var shorten_js_1 = require("./shorten.js");
+Object.defineProperty(exports, "stringShorten", { enumerable: true, get: function () { return shorten_js_1.stringShorten; } });
+var toHex_js_1 = require("./toHex.js");
+Object.defineProperty(exports, "stringToHex", { enumerable: true, get: function () { return toHex_js_1.stringToHex; } });
+var toU8a_js_1 = require("./toU8a.js");
+Object.defineProperty(exports, "stringToU8a", { enumerable: true, get: function () { return toU8a_js_1.stringToU8a; } });