@tstdl/base 0.87.13 → 0.88.0-alpha1

package/utils/type-of.js

@@ -1,46 +1,28 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var type_of_exports = {};
-__export(type_of_exports, {
-  typeOf: () => typeOf
-});
-module.exports = __toCommonJS(type_of_exports);
-var import_type_guards = require("./type-guards.js");
-function typeOf(value) {
-  const type = typeof value;
-  if (type == "function") {
-    const functionString = value.toString();
-    const name = value.name.length == 0 ? "anonymous" : value.name;
-    if (functionString.startsWith("class")) {
-      return `[class ${name}]`;
+/* eslint-disable @typescript-eslint/ban-types */
+import { isNull } from './type-guards.js';
+/**
+ * get the type of value. Returns 'null' instead of 'object' for null, tries to distinguish between function and class and to get their names
+ * @param value value to get type of
+ */
+export function typeOf(value) {
+    const type = typeof value;
+    if (type == 'function') {
+        const functionString = value.toString();
+        const name = (value.name.length == 0) ? 'anonymous' : value.name;
+        if (functionString.startsWith('class')) {
+            return `[class ${name}]`;
+        }
+        return `[function ${name}]`;
     }
-    return `[function ${name}]`;
-  }
-  if (type == "object") {
-    if ((0, import_type_guards.isNull)(value)) {
-      return "null";
+    if (type == 'object') {
+        if (isNull(value)) {
+            return 'null';
+        }
+        const constructor = (value.prototype ?? Object.getPrototypeOf(value)).constructor;
+        if (constructor != Object) {
+            const name = (constructor.name.length == 0) ? 'anonymous' : constructor.name;
+            return `[instanceof ${name}]`;
+        }
     }
-    const constructor = (value.prototype ?? Object.getPrototypeOf(value)).constructor;
-    if (constructor != Object) {
-      const name = constructor.name.length == 0 ? "anonymous" : constructor.name;
-      return `[instanceof ${name}]`;
-    }
-  }
-  return type;
+    return type;
 }

package/utils/units.js

@@ -1,124 +1,53 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var units_exports = {};
-__export(units_exports, {
-  daysPerWeek: () => daysPerWeek,
-  daysPerYear: () => daysPerYear,
-  exabyte: () => exabyte,
-  exbibyte: () => exbibyte,
-  gibibyte: () => gibibyte,
-  gigabyte: () => gigabyte,
-  hoursPerDay: () => hoursPerDay,
-  hoursPerWeek: () => hoursPerWeek,
-  hoursPerYear: () => hoursPerYear,
-  kibibyte: () => kibibyte,
-  kilobyte: () => kilobyte,
-  mebibyte: () => mebibyte,
-  megabyte: () => megabyte,
-  microsecondsPerDay: () => microsecondsPerDay,
-  microsecondsPerHour: () => microsecondsPerHour,
-  microsecondsPerMillisecond: () => microsecondsPerMillisecond,
-  microsecondsPerMinute: () => microsecondsPerMinute,
-  microsecondsPerSecond: () => microsecondsPerSecond,
-  microsecondsPerWeek: () => microsecondsPerWeek,
-  microsecondsPerYear: () => microsecondsPerYear,
-  millisecondsPerDay: () => millisecondsPerDay,
-  millisecondsPerHour: () => millisecondsPerHour,
-  millisecondsPerMinute: () => millisecondsPerMinute,
-  millisecondsPerSecond: () => millisecondsPerSecond,
-  millisecondsPerWeek: () => millisecondsPerWeek,
-  millisecondsPerYear: () => millisecondsPerYear,
-  minutesPerDay: () => minutesPerDay,
-  minutesPerHour: () => minutesPerHour,
-  minutesPerWeek: () => minutesPerWeek,
-  minutesPerYear: () => minutesPerYear,
-  nanosecondsPerDay: () => nanosecondsPerDay,
-  nanosecondsPerHour: () => nanosecondsPerHour,
-  nanosecondsPerMicrosecond: () => nanosecondsPerMicrosecond,
-  nanosecondsPerMillisecond: () => nanosecondsPerMillisecond,
-  nanosecondsPerMinute: () => nanosecondsPerMinute,
-  nanosecondsPerSecond: () => nanosecondsPerSecond,
-  nanosecondsPerWeek: () => nanosecondsPerWeek,
-  nanosecondsPerYear: () => nanosecondsPerYear,
-  pebibyte: () => pebibyte,
-  petabyte: () => petabyte,
-  secondsPerDay: () => secondsPerDay,
-  secondsPerHour: () => secondsPerHour,
-  secondsPerMinute: () => secondsPerMinute,
-  secondsPerWeek: () => secondsPerWeek,
-  secondsPerYear: () => secondsPerYear,
-  tebibyte: () => tebibyte,
-  terabyte: () => terabyte,
-  yobibyte: () => yobibyte,
-  yottabyte: () => yottabyte,
-  zebibyte: () => zebibyte,
-  zettabyte: () => zettabyte
-});
-module.exports = __toCommonJS(units_exports);
-const kilobyte = 1e3;
-const megabyte = 1e3 * kilobyte;
-const gigabyte = 1e3 * megabyte;
-const terabyte = 1e3 * gigabyte;
-const petabyte = 1e3 * terabyte;
-const exabyte = 1e3 * petabyte;
-const zettabyte = 1e3 * exabyte;
-const yottabyte = 1e3 * zettabyte;
-const kibibyte = 1024;
-const mebibyte = 1024 * kibibyte;
-const gibibyte = 1024 * mebibyte;
-const tebibyte = 1024 * gibibyte;
-const pebibyte = 1024 * tebibyte;
-const exbibyte = 1024 * pebibyte;
-const zebibyte = 1024 * exbibyte;
-const yobibyte = 1024 * zebibyte;
-const nanosecondsPerMicrosecond = 1e3;
-const nanosecondsPerMillisecond = 1e3 * nanosecondsPerMicrosecond;
-const nanosecondsPerSecond = 1e3 * nanosecondsPerMillisecond;
-const nanosecondsPerMinute = 60 * nanosecondsPerSecond;
-const nanosecondsPerHour = 60 * nanosecondsPerMinute;
-const nanosecondsPerDay = 24 * nanosecondsPerHour;
-const nanosecondsPerWeek = 7 * nanosecondsPerDay;
-const nanosecondsPerYear = 365 * nanosecondsPerDay;
-const microsecondsPerMillisecond = 1e3;
-const microsecondsPerSecond = 1e3 * microsecondsPerMillisecond;
-const microsecondsPerMinute = 60 * microsecondsPerSecond;
-const microsecondsPerHour = 60 * microsecondsPerMinute;
-const microsecondsPerDay = 24 * microsecondsPerHour;
-const microsecondsPerWeek = 7 * microsecondsPerDay;
-const microsecondsPerYear = 365 * microsecondsPerDay;
-const millisecondsPerSecond = 1e3;
-const millisecondsPerMinute = 60 * millisecondsPerSecond;
-const millisecondsPerHour = 60 * millisecondsPerMinute;
-const millisecondsPerDay = 24 * millisecondsPerHour;
-const millisecondsPerWeek = 7 * millisecondsPerDay;
-const millisecondsPerYear = 365 * millisecondsPerDay;
-const secondsPerMinute = 60;
-const secondsPerHour = 60 * secondsPerMinute;
-const secondsPerDay = 24 * secondsPerHour;
-const secondsPerWeek = 7 * secondsPerDay;
-const secondsPerYear = 365 * secondsPerDay;
-const minutesPerHour = 60;
-const minutesPerDay = 24 * minutesPerHour;
-const minutesPerWeek = 7 * minutesPerDay;
-const minutesPerYear = 365 * minutesPerDay;
-const hoursPerDay = 24;
-const hoursPerWeek = 7 * hoursPerDay;
-const hoursPerYear = 365 * hoursPerDay;
-const daysPerWeek = 7;
-const daysPerYear = 365;
+/* data sizes */
+export const kilobyte = 1000;
+export const megabyte = 1000 * kilobyte;
+export const gigabyte = 1000 * megabyte;
+export const terabyte = 1000 * gigabyte;
+export const petabyte = 1000 * terabyte;
+export const exabyte = 1000 * petabyte;
+export const zettabyte = 1000 * exabyte;
+export const yottabyte = 1000 * zettabyte;
+export const kibibyte = 1024;
+export const mebibyte = 1024 * kibibyte;
+export const gibibyte = 1024 * mebibyte;
+export const tebibyte = 1024 * gibibyte;
+export const pebibyte = 1024 * tebibyte;
+export const exbibyte = 1024 * pebibyte;
+export const zebibyte = 1024 * exbibyte;
+export const yobibyte = 1024 * zebibyte;
+/* durations */
+export const nanosecondsPerMicrosecond = 1000;
+export const nanosecondsPerMillisecond = 1000 * nanosecondsPerMicrosecond;
+export const nanosecondsPerSecond = 1000 * nanosecondsPerMillisecond;
+export const nanosecondsPerMinute = 60 * nanosecondsPerSecond;
+export const nanosecondsPerHour = 60 * nanosecondsPerMinute;
+export const nanosecondsPerDay = 24 * nanosecondsPerHour;
+export const nanosecondsPerWeek = 7 * nanosecondsPerDay;
+export const nanosecondsPerYear = 365 * nanosecondsPerDay;
+export const microsecondsPerMillisecond = 1000;
+export const microsecondsPerSecond = 1000 * microsecondsPerMillisecond;
+export const microsecondsPerMinute = 60 * microsecondsPerSecond;
+export const microsecondsPerHour = 60 * microsecondsPerMinute;
+export const microsecondsPerDay = 24 * microsecondsPerHour;
+export const microsecondsPerWeek = 7 * microsecondsPerDay;
+export const microsecondsPerYear = 365 * microsecondsPerDay;
+export const millisecondsPerSecond = 1000;
+export const millisecondsPerMinute = 60 * millisecondsPerSecond;
+export const millisecondsPerHour = 60 * millisecondsPerMinute;
+export const millisecondsPerDay = 24 * millisecondsPerHour;
+export const millisecondsPerWeek = 7 * millisecondsPerDay;
+export const millisecondsPerYear = 365 * millisecondsPerDay;
+export const secondsPerMinute = 60;
+export const secondsPerHour = 60 * secondsPerMinute;
+export const secondsPerDay = 24 * secondsPerHour;
+export const secondsPerWeek = 7 * secondsPerDay;
+export const secondsPerYear = 365 * secondsPerDay;
+export const minutesPerHour = 60;
+export const minutesPerDay = 24 * minutesPerHour;
+export const minutesPerWeek = 7 * minutesPerDay;
+export const minutesPerYear = 365 * minutesPerDay;
+export const hoursPerDay = 24;
+export const hoursPerWeek = 7 * hoursPerDay;
+export const hoursPerYear = 365 * hoursPerDay;
+export const daysPerWeek = 7;
+export const daysPerYear = 365;

package/utils/url-builder.js

@@ -1,78 +1,57 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var url_builder_exports = {};
-__export(url_builder_exports, {
-  buildUrl: () => buildUrl,
-  compileUrlBuilder: () => compileUrlBuilder
-});
-module.exports = __toCommonJS(url_builder_exports);
-var import_types = require("../http/types.js");
-var import_memoize = require("./function/memoize.js");
-var import_type_guards = require("./type-guards.js");
+import { normalizeHttpValue } from '../http/types.js';
+import { memoizeSingle } from './function/memoize.js';
+import { isArray, isDefined, isObject, isUndefined } from './type-guards.js';
 var UrlBuilderPartType;
-(function(UrlBuilderPartType2) {
-  UrlBuilderPartType2[UrlBuilderPartType2["Literal"] = 0] = "Literal";
-  UrlBuilderPartType2[UrlBuilderPartType2["Parameter"] = 1] = "Parameter";
+(function (UrlBuilderPartType) {
+    UrlBuilderPartType[UrlBuilderPartType["Literal"] = 0] = "Literal";
+    UrlBuilderPartType[UrlBuilderPartType["Parameter"] = 1] = "Parameter";
 })(UrlBuilderPartType || (UrlBuilderPartType = {}));
 const urlParseRegex = /([^:]+|:\/+)|:([\w-]+)/ug;
 const isFullUrlRegex = /^\w+:\/\//u;
-function compileUrlBuilder(url) {
-  const parts = [];
-  const isFullUrl = isFullUrlRegex.test(url);
-  let parseUrl = url;
-  if (isFullUrl) {
-    const { origin } = new URL(url);
-    parts.push({ type: UrlBuilderPartType.Literal, value: origin });
-    parseUrl = url.slice(origin.length);
-  }
-  const matches = parseUrl.matchAll(urlParseRegex);
-  for (const [, literal, parameter] of matches) {
-    if ((0, import_type_guards.isDefined)(literal)) {
-      parts.push({ type: UrlBuilderPartType.Literal, value: literal });
-    } else if ((0, import_type_guards.isDefined)(parameter)) {
-      parts.push({ type: UrlBuilderPartType.Parameter, value: parameter });
+// eslint-disable-next-line max-lines-per-function
+export function compileUrlBuilder(url) {
+    const parts = [];
+    const isFullUrl = isFullUrlRegex.test(url);
+    let parseUrl = url;
+    if (isFullUrl) {
+        const { origin } = new URL(url);
+        parts.push({ type: UrlBuilderPartType.Literal, value: origin });
+        parseUrl = url.slice(origin.length);
     }
-  }
-  function buildUrlCompiled(parameters = {}, { arraySeparator = "," } = {}) {
-    let parsedUrl = "";
-    let value;
-    let parametersRest = parameters;
-    for (const part of parts) {
-      if (part.type == UrlBuilderPartType.Literal) {
-        parsedUrl += part.value;
-      } else {
-        ({ [part.value]: value, ...parametersRest } = parametersRest);
-        if ((0, import_type_guards.isUndefined)(value)) {
-          throw new Error(`Url parameter ${part.value} not provided. (${url})`);
+    const matches = parseUrl.matchAll(urlParseRegex);
+    for (const [, literal, parameter] of matches) {
+        if (isDefined(literal)) {
+            parts.push({ type: UrlBuilderPartType.Literal, value: literal });
         }
-        if ((0, import_type_guards.isObject)(value)) {
-          throw new Error(`Url parameter ${part.value} is an object. (${url})`);
+        else if (isDefined(parameter)) {
+            parts.push({ type: UrlBuilderPartType.Parameter, value: parameter });
         }
-        parsedUrl += (0, import_type_guards.isArray)(value) ? value.map(import_types.normalizeHttpValue).join(arraySeparator) : (0, import_types.normalizeHttpValue)(value);
-      }
     }
-    return { parsedUrl, parametersRest };
-  }
-  return buildUrlCompiled;
+    function buildUrlCompiled(parameters = {}, { arraySeparator = ',' } = {}) {
+        let parsedUrl = '';
+        let value;
+        let parametersRest = parameters;
+        for (const part of parts) {
+            if (part.type == UrlBuilderPartType.Literal) {
+                parsedUrl += part.value;
+            }
+            else {
+                ({ [part.value]: value, ...parametersRest } = parametersRest);
+                if (isUndefined(value)) {
+                    throw new Error(`Url parameter ${part.value} not provided. (${url})`);
+                }
+                if (isObject(value)) {
+                    throw new Error(`Url parameter ${part.value} is an object. (${url})`);
+                }
+                parsedUrl += isArray(value) ? value.map(normalizeHttpValue).join(arraySeparator) : normalizeHttpValue(value);
+            }
+        }
+        return { parsedUrl, parametersRest };
+    }
+    return buildUrlCompiled;
 }
-const memoizedCompileUrlBuilder = (0, import_memoize.memoizeSingle)(compileUrlBuilder);
-function buildUrl(url, parameters = {}, options) {
-  const builder = memoizedCompileUrlBuilder(url);
-  return builder(parameters, options);
+const memoizedCompileUrlBuilder = memoizeSingle(compileUrlBuilder);
+export function buildUrl(url, parameters = {}, options) {
+    const builder = memoizedCompileUrlBuilder(url);
+    return builder(parameters, options);
 }

package/utils/value-or-provider.js

@@ -1,47 +1,22 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var value_or_provider_exports = {};
-__export(value_or_provider_exports, {
-  cacheAsyncValueOrProvider: () => cacheAsyncValueOrProvider,
-  resolveAsyncValueOrProvider: () => resolveAsyncValueOrProvider,
-  resolveValueOrProvider: () => resolveValueOrProvider
-});
-module.exports = __toCommonJS(value_or_provider_exports);
-var import_type_guards = require("./type-guards.js");
-function resolveValueOrProvider(valueOrProvider) {
-  if ((0, import_type_guards.isFunction)(valueOrProvider)) {
-    return valueOrProvider();
-  }
-  return valueOrProvider;
+import { isFunction } from './type-guards.js';
+export function resolveValueOrProvider(valueOrProvider) {
+    if (isFunction(valueOrProvider)) {
+        return valueOrProvider();
+    }
+    return valueOrProvider;
 }
-async function resolveAsyncValueOrProvider(valueOrProvider) {
-  if ((0, import_type_guards.isFunction)(valueOrProvider)) {
-    return valueOrProvider();
-  }
-  return valueOrProvider;
+export async function resolveAsyncValueOrProvider(valueOrProvider) {
+    if (isFunction(valueOrProvider)) {
+        return valueOrProvider();
+    }
+    return valueOrProvider;
 }
-function cacheAsyncValueOrProvider(provider) {
-  let getValue = async () => {
-    const valuePromise = resolveAsyncValueOrProvider(provider);
-    getValue = async () => valuePromise;
-    void valuePromise.then((resolvedValue) => getValue = () => resolvedValue);
-    return valuePromise;
-  };
-  return () => getValue();
+export function cacheAsyncValueOrProvider(provider) {
+    let getValue = async () => {
+        const valuePromise = resolveAsyncValueOrProvider(provider);
+        getValue = async () => valuePromise;
+        void valuePromise.then((resolvedValue) => (getValue = () => resolvedValue));
+        return valuePromise;
+    };
+    return () => getValue(); // eslint-disable-line @typescript-eslint/promise-function-async
 }

package/utils/z-base32.js

@@ -1,67 +1,46 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var z_base32_exports = {};
-__export(z_base32_exports, {
-  zBase32Decode: () => zBase32Decode,
-  zBase32Encode: () => zBase32Encode
-});
-module.exports = __toCommonJS(z_base32_exports);
-var import_alphabet = require("./alphabet.js");
-var import_binary = require("./binary.js");
-const alphabet = import_alphabet.Alphabet.ZBase32;
-const charValueMap = new Map(alphabet.split("").map((char, index) => [char, index]));
-function zBase32Encode(buffer) {
-  const byteView = (0, import_binary.toUint8Array)(buffer);
-  let result = "";
-  let bits = 0;
-  let value = 0;
-  for (let i = 0; i < byteView.byteLength; i++) {
-    value = value << 8 | byteView[i];
-    bits += 8;
-    while (bits >= 5) {
-      const quantum = value >>> bits - 5 & 31;
-      result += alphabet[quantum];
-      bits -= 5;
+/* eslint-disable no-bitwise, @typescript-eslint/no-magic-numbers */
+import { Alphabet } from './alphabet.js';
+import { toUint8Array } from './binary.js';
+const alphabet = Alphabet.ZBase32;
+const charValueMap = new Map(alphabet.split('').map((char, index) => [char, index]));
+// eslint-disable-next-line max-statements
+export function zBase32Encode(buffer) {
+    const byteView = toUint8Array(buffer);
+    let result = '';
+    let bits = 0;
+    let value = 0;
+    for (let i = 0; i < byteView.byteLength; i++) {
+        value = (value << 8) | byteView[i];
+        bits += 8;
+        while (bits >= 5) {
+            const quantum = (value >>> (bits - 5)) & 31;
+            result += alphabet[quantum];
+            bits -= 5;
+        }
     }
-  }
-  if (bits > 0) {
-    result += alphabet[value << 5 - bits & 31];
-  }
-  return result;
-}
-function zBase32Decode(input) {
-  const bytes = new Uint8Array(input.length * 5 / 8 | 0);
-  let bits = 0;
-  let value = 0;
-  let byteIndex = 0;
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    const charValue = charValueMap.get(char);
-    if (charValue == void 0) {
-      throw new Error(`invalid character at index ${i}`);
+    if (bits > 0) {
+        result += alphabet[(value << (5 - bits)) & 31];
     }
-    value = value << 5 | charValue;
-    bits += 5;
-    if (bits >= 8) {
-      bytes[byteIndex++] = value >>> bits - 8 & 255;
-      bits -= 8;
+    return result;
+}
+// eslint-disable-next-line max-statements
+export function zBase32Decode(input) {
+    const bytes = new Uint8Array((input.length * 5 / 8) | 0);
+    let bits = 0;
+    let value = 0;
+    let byteIndex = 0;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        const charValue = charValueMap.get(char);
+        if (charValue == undefined) {
+            throw new Error(`invalid character at index ${i}`);
+        }
+        value = (value << 5) | charValue;
+        bits += 5;
+        if (bits >= 8) {
+            bytes[byteIndex++] = (value >>> (bits - 8)) & 255;
+            bits -= 8;
+        }
     }
-  }
-  return bytes;
+    return bytes;
 }

package/web-types.js

@@ -1,16 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var web_types_exports = {};
-module.exports = __toCommonJS(web_types_exports);
+export {};