@tstdl/base 0.86.0-beta2 → 0.86.0-beta4

package/utils/type-of.js

@@ -1,28 +1,46 @@
-/* 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}]`;
+"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}]`;
     }
-    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}]`;
-        }
+    return `[function ${name}]`;
+  }
+  if (type == "object") {
+    if ((0, import_type_guards.isNull)(value)) {
+      return "null";
     }
-    return type;
+    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;
 }

package/utils/units.js

@@ -1,53 +1,124 @@
-/* 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;
+"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;

package/utils/url-builder.js

@@ -1,57 +1,78 @@
-import { normalizeHttpValue } from '../http/types.js';
-import { memoizeSingle } from './function/memoize.js';
-import { isArray, isDefined, isObject, isUndefined } from './type-guards.js';
+"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");
 var UrlBuilderPartType;
-(function (UrlBuilderPartType) {
-    UrlBuilderPartType[UrlBuilderPartType["Literal"] = 0] = "Literal";
-    UrlBuilderPartType[UrlBuilderPartType["Parameter"] = 1] = "Parameter";
+(function(UrlBuilderPartType2) {
+  UrlBuilderPartType2[UrlBuilderPartType2["Literal"] = 0] = "Literal";
+  UrlBuilderPartType2[UrlBuilderPartType2["Parameter"] = 1] = "Parameter";
 })(UrlBuilderPartType || (UrlBuilderPartType = {}));
 const urlParseRegex = /([^:]+|:\/+)|:([\w-]+)/ug;
 const isFullUrlRegex = /^\w+:\/\//u;
-// 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 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 });
     }
-    const matches = parseUrl.matchAll(urlParseRegex);
-    for (const [, literal, parameter] of matches) {
-        if (isDefined(literal)) {
-            parts.push({ type: UrlBuilderPartType.Literal, value: literal });
+  }
+  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})`);
         }
-        else if (isDefined(parameter)) {
-            parts.push({ type: UrlBuilderPartType.Parameter, value: parameter });
+        if ((0, import_type_guards.isObject)(value)) {
+          throw new Error(`Url parameter ${part.value} is an object. (${url})`);
         }
+        parsedUrl += (0, import_type_guards.isArray)(value) ? value.map(import_types.normalizeHttpValue).join(arraySeparator) : (0, import_types.normalizeHttpValue)(value);
+      }
     }
-    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;
+    return { parsedUrl, parametersRest };
+  }
+  return buildUrlCompiled;
 }
-const memoizedCompileUrlBuilder = memoizeSingle(compileUrlBuilder);
-export function buildUrl(url, parameters = {}, options) {
-    const builder = memoizedCompileUrlBuilder(url);
-    return builder(parameters, options);
+const memoizedCompileUrlBuilder = (0, import_memoize.memoizeSingle)(compileUrlBuilder);
+function buildUrl(url, parameters = {}, options) {
+  const builder = memoizedCompileUrlBuilder(url);
+  return builder(parameters, options);
 }

package/utils/value-or-provider.js

@@ -1,7 +1,30 @@
-import { isFunction } from './type-guards.js';
-export function resolveValueOrProvider(valueOrProvider) {
-    if (isFunction(valueOrProvider)) {
-        return valueOrProvider();
-    }
-    return valueOrProvider;
+"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, {
+  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;
 }

package/utils/z-base32.js

@@ -1,46 +1,67 @@
-/* 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;
-        }
+"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;
     }
-    if (bits > 0) {
-        result += alphabet[(value << (5 - bits)) & 31];
-    }
-    return result;
+  }
+  if (bits > 0) {
+    result += alphabet[value << 5 - bits & 31];
+  }
+  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;
-        }
+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}`);
+    }
+    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 +1,16 @@
-export {};
+"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);