@tstdl/base 0.86.0-beta1 → 0.86.0-beta11

package/utils/iterable-helpers/skip.js

@@ -1,8 +1,31 @@
-export function* skip(iterable, count) {
-    let index = 0;
-    for (const item of iterable) {
-        if (index++ >= count) {
-            yield item;
-        }
+"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 skip_exports = {};
+__export(skip_exports, {
+  skip: () => skip
+});
+module.exports = __toCommonJS(skip_exports);
+function* skip(iterable, count) {
+  let index = 0;
+  for (const item of iterable) {
+    if (index++ >= count) {
+      yield item;
     }
+  }
 }

package/utils/iterable-helpers/sort.js

@@ -1,5 +1,28 @@
-import { compareByValue } from '../comparison.js';
-export function sort(iterable, comparator = compareByValue) {
-    const array = [...iterable];
-    return array.sort(comparator);
+"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 sort_exports = {};
+__export(sort_exports, {
+  sort: () => sort
+});
+module.exports = __toCommonJS(sort_exports);
+var import_comparison = require("../comparison.js");
+function sort(iterable, comparator = import_comparison.compareByValue) {
+  const array = [...iterable];
+  return array.sort(comparator);
 }

package/utils/iterable-helpers/take-until.js

@@ -1,10 +1,33 @@
-export function* takeUntil(iterable, cancellationToken) {
-    const iterator = iterable[Symbol.iterator]();
-    while (cancellationToken.isUnset) {
-        const result = iterator.next();
-        if (result.done == true) {
-            return;
-        }
-        yield result.value;
+"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 take_until_exports = {};
+__export(take_until_exports, {
+  takeUntil: () => takeUntil
+});
+module.exports = __toCommonJS(take_until_exports);
+function* takeUntil(iterable, cancellationToken) {
+  const iterator = iterable[Symbol.iterator]();
+  while (cancellationToken.isUnset) {
+    const result = iterator.next();
+    if (result.done == true) {
+      return;
     }
+    yield result.value;
+  }
 }

package/utils/iterable-helpers/take-while.js

@@ -1,12 +1,35 @@
-export function* takeWhile(iterable, yieldLastOnFalse, predicate) {
-    let index = 0;
-    for (const item of iterable) {
-        const take = predicate(item, index++);
-        if (take || yieldLastOnFalse) {
-            yield item;
-        }
-        if (!take) {
-            break;
-        }
+"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 take_while_exports = {};
+__export(take_while_exports, {
+  takeWhile: () => takeWhile
+});
+module.exports = __toCommonJS(take_while_exports);
+function* takeWhile(iterable, yieldLastOnFalse, predicate) {
+  let index = 0;
+  for (const item of iterable) {
+    const take = predicate(item, index++);
+    if (take || yieldLastOnFalse) {
+      yield item;
     }
+    if (!take) {
+      break;
+    }
+  }
 }

package/utils/iterable-helpers/take.js

@@ -1,12 +1,35 @@
-export function* take(iterable, count) {
-    if (count <= 0) {
-        return;
-    }
-    let counter = 0;
-    for (const item of iterable) {
-        yield item;
-        if (++counter >= count) {
-            break;
-        }
+"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 take_exports = {};
+__export(take_exports, {
+  take: () => take
+});
+module.exports = __toCommonJS(take_exports);
+function* take(iterable, count) {
+  if (count <= 0) {
+    return;
+  }
+  let counter = 0;
+  for (const item of iterable) {
+    yield item;
+    if (++counter >= count) {
+      break;
     }
+  }
 }

package/utils/iterable-helpers/tap.js

@@ -1,7 +1,30 @@
-export function* tap(iterable, tapper) {
-    let index = 0;
-    for (const item of iterable) {
-        tapper(item, index++);
-        yield item;
-    }
+"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 tap_exports = {};
+__export(tap_exports, {
+  tap: () => tap
+});
+module.exports = __toCommonJS(tap_exports);
+function* tap(iterable, tapper) {
+  let index = 0;
+  for (const item of iterable) {
+    tapper(item, index++);
+    yield item;
+  }
 }

package/utils/iterable-helpers/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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/utils/iterable-helpers/while.js

@@ -1,10 +1,33 @@
-export function* whileSync(iterable, predicate) {
-    let index = 0;
-    for (const item of iterable) {
-        yield item;
-        const goOn = predicate(item, index++);
-        if (!goOn) {
-            return;
-        }
+"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 while_exports = {};
+__export(while_exports, {
+  whileSync: () => whileSync
+});
+module.exports = __toCommonJS(while_exports);
+function* whileSync(iterable, predicate) {
+  let index = 0;
+  for (const item of iterable) {
+    yield item;
+    const goOn = predicate(item, index++);
+    if (!goOn) {
+      return;
     }
+  }
 }

package/utils/jwt.js

@@ -1,88 +1,111 @@
-import { InvalidTokenError } from '../error/invalid-token.error.js';
-import { toArray } from './array/array.js';
-import { decodeBase64Url, encodeBase64Url } from './base64.js';
-import { importHmacKey, sign } from './cryptography.js';
-import { encodeUtf8 } from './encoding.js';
-import { binaryEquals } from './equals.js';
-export function parseJwtTokenString(tokenString) {
-    const splits = tokenString.split('.');
-    if (splits.length != 3) {
-        const message = (tokenString.length > 0) ? 'Invalid token format' : 'Missing authorization token';
-        throw new InvalidTokenError(message);
-    }
-    const [encodedHeader, encodedPayload, encodedSignature] = splits;
-    const textDecoder = new TextDecoder();
-    const encoded = {
-        header: encodedHeader,
-        payload: encodedPayload,
-        signature: encodedSignature
-    };
-    const bytes = {
-        header: decodeBase64Url(encodedHeader),
-        payload: decodeBase64Url(encodedPayload),
-        signature: decodeBase64Url(encodedSignature)
+"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 jwt_exports = {};
+__export(jwt_exports, {
+  createJwtTokenString: () => createJwtTokenString,
+  parseAndValidateJwtTokenString: () => parseAndValidateJwtTokenString,
+  parseJwtTokenString: () => parseJwtTokenString
+});
+module.exports = __toCommonJS(jwt_exports);
+var import_invalid_token_error = require("../error/invalid-token.error.js");
+var import_array = require("./array/array.js");
+var import_base64 = require("./base64.js");
+var import_cryptography = require("./cryptography.js");
+var import_encoding = require("./encoding.js");
+var import_equals = require("./equals.js");
+function parseJwtTokenString(tokenString) {
+  const splits = tokenString.split(".");
+  if (splits.length != 3) {
+    const message = tokenString.length > 0 ? "Invalid token format" : "Missing authorization token";
+    throw new import_invalid_token_error.InvalidTokenError(message);
+  }
+  const [encodedHeader, encodedPayload, encodedSignature] = splits;
+  const textDecoder = new TextDecoder();
+  const encoded = {
+    header: encodedHeader,
+    payload: encodedPayload,
+    signature: encodedSignature
+  };
+  const bytes = {
+    header: (0, import_base64.decodeBase64Url)(encodedHeader),
+    payload: (0, import_base64.decodeBase64Url)(encodedPayload),
+    signature: (0, import_base64.decodeBase64Url)(encodedSignature)
+  };
+  const string = {
+    header: textDecoder.decode(bytes.header),
+    payload: textDecoder.decode(bytes.payload)
+  };
+  try {
+    const header = JSON.parse(string.header);
+    const payload = JSON.parse(string.payload);
+    const token = {
+      header,
+      payload
     };
-    const string = {
-        header: textDecoder.decode(bytes.header),
-        payload: textDecoder.decode(bytes.payload)
+    return {
+      raw: tokenString,
+      token,
+      encoded,
+      bytes,
+      string
     };
-    try {
-        const header = JSON.parse(string.header);
-        const payload = JSON.parse(string.payload);
-        const token = {
-            header,
-            payload
-        };
-        return {
-            raw: tokenString,
-            token: token,
-            encoded,
-            bytes,
-            string
-        };
-    }
-    catch {
-        throw new InvalidTokenError('Invalid token format');
-    }
+  } catch {
+    throw new import_invalid_token_error.InvalidTokenError("Invalid token format");
+  }
 }
-export async function createJwtTokenString(jwtToken, key) {
-    const headerBuffer = encodeUtf8(JSON.stringify(jwtToken.header));
-    const payloadBuffer = encodeUtf8(JSON.stringify(jwtToken.payload));
-    const encodedHeader = encodeBase64Url(headerBuffer, 0, headerBuffer.byteLength);
-    const encodedPayload = encodeBase64Url(payloadBuffer, 0, payloadBuffer.byteLength);
-    const headerPayloadDataString = `${encodedHeader}.${encodedPayload}`;
-    const headerPayloadData = encodeUtf8(headerPayloadDataString);
-    const signature = await getSignature(headerPayloadData, jwtToken.header.alg, key);
-    const encodedSignature = encodeBase64Url(signature);
-    const tokenString = `${headerPayloadDataString}.${encodedSignature}`;
-    return tokenString;
+async function createJwtTokenString(jwtToken, key) {
+  const headerBuffer = (0, import_encoding.encodeUtf8)(JSON.stringify(jwtToken.header));
+  const payloadBuffer = (0, import_encoding.encodeUtf8)(JSON.stringify(jwtToken.payload));
+  const encodedHeader = (0, import_base64.encodeBase64Url)(headerBuffer, 0, headerBuffer.byteLength);
+  const encodedPayload = (0, import_base64.encodeBase64Url)(payloadBuffer, 0, payloadBuffer.byteLength);
+  const headerPayloadDataString = `${encodedHeader}.${encodedPayload}`;
+  const headerPayloadData = (0, import_encoding.encodeUtf8)(headerPayloadDataString);
+  const signature = await getSignature(headerPayloadData, jwtToken.header.alg, key);
+  const encodedSignature = (0, import_base64.encodeBase64Url)(signature);
+  const tokenString = `${headerPayloadDataString}.${encodedSignature}`;
+  return tokenString;
 }
-export async function parseAndValidateJwtTokenString(tokenString, allowedAlgorithms, key) {
-    try {
-        const { encoded, bytes, token } = parseJwtTokenString(tokenString);
-        if (!toArray(allowedAlgorithms).includes(token.header.alg)) {
-            throw new InvalidTokenError('Invalid signature algorithm');
-        }
-        const calculatedSignature = await getSignature(encodeUtf8(`${encoded.header}.${encoded.payload}`), token.header.alg, key);
-        const validSignature = binaryEquals(calculatedSignature, bytes.signature);
-        if (!validSignature) {
-            throw new InvalidTokenError('Invalid token signature');
-        }
-        return token;
+async function parseAndValidateJwtTokenString(tokenString, allowedAlgorithms, key) {
+  try {
+    const { encoded, bytes, token } = parseJwtTokenString(tokenString);
+    if (!(0, import_array.toArray)(allowedAlgorithms).includes(token.header.alg)) {
+      throw new import_invalid_token_error.InvalidTokenError("Invalid signature algorithm");
+    }
+    const calculatedSignature = await getSignature((0, import_encoding.encodeUtf8)(`${encoded.header}.${encoded.payload}`), token.header.alg, key);
+    const validSignature = (0, import_equals.binaryEquals)(calculatedSignature, bytes.signature);
+    if (!validSignature) {
+      throw new import_invalid_token_error.InvalidTokenError("Invalid token signature");
     }
-    catch (error) {
-        if (error instanceof InvalidTokenError) {
-            throw error;
-        }
-        throw new InvalidTokenError('Invalid token');
+    return token;
+  } catch (error) {
+    if (error instanceof import_invalid_token_error.InvalidTokenError) {
+      throw error;
     }
+    throw new import_invalid_token_error.InvalidTokenError("Invalid token");
+  }
 }
 async function getSignature(data, algorithm, secret) {
-    const hashAlgorithm = getHmacHashAlgorithm(algorithm);
-    const hmacKey = await importHmacKey(hashAlgorithm, secret, false);
-    const hmacSignature = sign('HMAC', hmacKey, data);
-    return hmacSignature.toBuffer();
+  const hashAlgorithm = getHmacHashAlgorithm(algorithm);
+  const hmacKey = await (0, import_cryptography.importHmacKey)(hashAlgorithm, secret, false);
+  const hmacSignature = (0, import_cryptography.sign)("HMAC", hmacKey, data);
+  return hmacSignature.toBuffer();
 }
 function getHmacHashAlgorithm(algorithm) {
-    return algorithm.replace('HS', 'SHA-');
+  return algorithm.replace("HS", "SHA-");
 }

package/utils/map.js

@@ -1,43 +1,70 @@
-import { compareByValueSelectionDescending } from './comparison.js';
-export function intersectMaps(...maps) {
-    if (maps.length == 0) {
-        return [];
-    }
-    if (maps.length == 1) {
-        return [...maps[0]];
-    }
-    const sortedMaps = maps.sort(compareByValueSelectionDescending((map) => map.size));
-    const [smallestMap, ...otherMaps] = sortedMaps;
-    return [...smallestMap].filter((entry) => !otherMaps.some((map) => !map.has(entry[0])));
+"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 map_exports = {};
+__export(map_exports, {
+  differenceMaps: () => differenceMaps,
+  intersectMaps: () => intersectMaps,
+  symmetricDifferenceMaps: () => symmetricDifferenceMaps,
+  unionMaps: () => unionMaps,
+  uniquesMaps: () => uniquesMaps
+});
+module.exports = __toCommonJS(map_exports);
+var import_comparison = require("./comparison.js");
+function intersectMaps(...maps) {
+  if (maps.length == 0) {
+    return [];
+  }
+  if (maps.length == 1) {
+    return [...maps[0]];
+  }
+  const sortedMaps = maps.sort((0, import_comparison.compareByValueSelectionDescending)((map) => map.size));
+  const [smallestMap, ...otherMaps] = sortedMaps;
+  return [...smallestMap].filter((entry) => !otherMaps.some((map) => !map.has(entry[0])));
 }
-export function differenceMaps(base, ...maps) {
-    return [...base].filter((entry) => !maps.some((map) => map.has(entry[0])));
+function differenceMaps(base, ...maps) {
+  return [...base].filter((entry) => !maps.some((map) => map.has(entry[0])));
 }
-export function symmetricDifferenceMaps(...maps) {
-    if (maps.length == 0) {
-        return new Map();
-    }
-    if (maps.length == 1) {
-        return maps[0];
-    }
-    const [first, second, ...others] = maps;
-    return symmetricDifferenceMaps(simpleSymmetricDifference(first, second), ...others);
+function symmetricDifferenceMaps(...maps) {
+  if (maps.length == 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (maps.length == 1) {
+    return maps[0];
+  }
+  const [first, second, ...others] = maps;
+  return symmetricDifferenceMaps(simpleSymmetricDifference(first, second), ...others);
 }
-export function uniquesMaps(...maps) {
-    const result = new Map();
-    for (const map of maps) {
-        for (const entry of map) {
-            const unique = maps.every((otherMap) => (map == otherMap) || !otherMap.has(entry[0]));
-            if (unique) {
-                result.set(entry[0], entry[1]);
-            }
-        }
+function uniquesMaps(...maps) {
+  const result = /* @__PURE__ */ new Map();
+  for (const map of maps) {
+    for (const entry of map) {
+      const unique = maps.every((otherMap) => map == otherMap || !otherMap.has(entry[0]));
+      if (unique) {
+        result.set(entry[0], entry[1]);
+      }
     }
-    return result;
+  }
+  return result;
 }
-export function unionMaps(...maps) {
-    return new Map(maps.flatMap((map) => [...map]));
+function unionMaps(...maps) {
+  return new Map(maps.flatMap((map) => [...map]));
 }
 function simpleSymmetricDifference(a, b) {
-    return unionMaps(differenceMaps(a, b), differenceMaps(b, a));
+  return unionMaps(differenceMaps(a, b), differenceMaps(b, a));
 }