@wener/utils 1.1.33 → 1.1.35

package/lib/http/HttpStatus.js

@@ -0,0 +1,94 @@
+// http://httpstat.us/
+// https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+const HttpStatus = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    103: 'Early Hints',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    207: 'Multi-Status',
+    208: 'Already Reported',
+    226: 'IM Used',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    305: 'Use Proxy',
+    306: 'Unused',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Required',
+    413: 'Request Entry Too Large',
+    414: 'Request-URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Requested Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: "I'm a teapot",
+    421: 'Misdirected Request',
+    422: 'Unprocessable Entity',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    509: 'Bandwidth Limit Exceeded',
+    510: 'Not Extended',
+    511: 'Network Authentication Required'
+};
+export function getHttpStatusText(status) {
+    return HttpStatus[status];
+}
+export function isRetryableHttpStatus(status) {
+    switch(status){
+        /*
+408 Request Timeout
+425 Too Early
+429 Too Many Requests
+500 Internal Server Error
+502 Bad Gateway
+503 Service Unavailable
+504 Gateway Timeout
+     */ case 408:
+        case 425:
+        case 429:
+        case 502:
+        case 503:
+        case 504:
+            return true;
+        default:
+            return false;
+    }
+}
+
+//# sourceMappingURL=HttpStatus.js.map

package/lib/http/HttpStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/http/HttpStatus.ts"],"sourcesContent":["// http://httpstat.us/\n// https://en.wikipedia.org/wiki/List_of_HTTP_status_codes\nconst HttpStatus: Record<string, string> = {\n  100: 'Continue',\n  101: 'Switching Protocols',\n  102: 'Processing',\n  103: 'Early Hints',\n  200: 'OK',\n  201: 'Created',\n  202: 'Accepted',\n  203: 'Non-Authoritative Information',\n  204: 'No Content',\n  205: 'Reset Content',\n  206: 'Partial Content',\n  207: 'Multi-Status',\n  208: 'Already Reported',\n  226: 'IM Used',\n  300: 'Multiple Choices',\n  301: 'Moved Permanently',\n  302: 'Found',\n  303: 'See Other',\n  304: 'Not Modified',\n  305: 'Use Proxy',\n  306: 'Unused',\n  307: 'Temporary Redirect',\n  308: 'Permanent Redirect',\n\n  400: 'Bad Request',\n  401: 'Unauthorized',\n  402: 'Payment Required',\n  403: 'Forbidden',\n  404: 'Not Found',\n  405: 'Method Not Allowed',\n  406: 'Not Acceptable',\n  407: 'Proxy Authentication Required',\n  408: 'Request Timeout',\n  409: 'Conflict',\n  410: 'Gone',\n  411: 'Length Required',\n  412: 'Precondition Required',\n  413: 'Request Entry Too Large',\n  414: 'Request-URI Too Long',\n  415: 'Unsupported Media Type',\n  416: 'Requested Range Not Satisfiable',\n  417: 'Expectation Failed',\n  418: \"I'm a teapot\",\n  421: 'Misdirected Request',\n  422: 'Unprocessable Entity',\n  423: 'Locked',\n  424: 'Failed Dependency',\n  425: 'Too Early',\n  426: 'Upgrade Required',\n  428: 'Precondition Required',\n  429: 'Too Many Requests',\n  431: 'Request Header Fields Too Large',\n  451: 'Unavailable For Legal Reasons',\n  500: 'Internal Server Error',\n  501: 'Not Implemented',\n  502: 'Bad Gateway',\n  503: 'Service Unavailable',\n  504: 'Gateway Timeout',\n  505: 'HTTP Version Not Supported',\n  506: 'Variant Also Negotiates',\n  507: 'Insufficient Storage',\n  508: 'Loop Detected',\n  509: 'Bandwidth Limit Exceeded',\n  510: 'Not Extended',\n  511: 'Network Authentication Required',\n};\n\nexport function getHttpStatusText(status: number | string): string | undefined {\n  return HttpStatus[status];\n}\n\nexport function isRetryableHttpStatus(status: number) {\n  switch (status) {\n    /*\n408 Request Timeout\n425 Too Early\n429 Too Many Requests\n500 Internal Server Error\n502 Bad Gateway\n503 Service Unavailable\n504 Gateway Timeout\n     */\n    case 408:\n    case 425:\n    case 429:\n    case 502:\n    case 503:\n    case 504:\n      return true;\n    default:\n      return false;\n  }\n}\n"],"names":["HttpStatus","getHttpStatusText","status","isRetryableHttpStatus"],"mappings":"AAAA,sBAAsB;AACtB,0DAA0D;AAC1D,MAAMA,aAAqC;IACzC,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IAEL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;AACP;AAEA,OAAO,SAASC,kBAAkBC,MAAuB;IACvD,OAAOF,UAAU,CAACE,OAAO;AAC3B;AAEA,OAAO,SAASC,sBAAsBD,MAAc;IAClD,OAAQA;QACN;;;;;;;;KAQC,GACD,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YACH,OAAO;QACT;YACE,OAAO;IACX;AACF"}

package/lib/i18n/createTranslate.js

@@ -0,0 +1,54 @@
+import { get } from '../objects/get.js';
+import { renderTemplate } from '../strings/renderTemplate.js';
+export function createTranslate(obj) {
+    let locale = '';
+    const tree = obj || {};
+    // en-US -> en-US,en
+    const keyOfDict = (s)=>{
+        if (Array.isArray(s)) {
+            return s;
+        }
+        const sp = s.split(/[_-]/);
+        if (sp.length > 1) {
+            return [
+                s,
+                sp[0]
+            ];
+        }
+        return [
+            s
+        ];
+    };
+    return {
+        locale (lang) {
+            return locale = lang || locale;
+        },
+        dict: (lang, dict)=>{
+            if (dict) {
+                tree[lang] = Object.assign(tree[lang] || {}, dict);
+                return;
+            }
+            return tree[lang];
+        },
+        t (key, params, lang) {
+            let val;
+            for (const k of keyOfDict(lang || locale)){
+                val = get(tree[k], key, '');
+                if (val) {
+                    break;
+                }
+            }
+            if (process.env.NODE_ENV === 'development') {
+                if (val == null) {
+                    console.error(`[Translate] Missing the "${[].concat(key).join('.')}" key within the "${lang || locale}" dictionary`);
+                    return;
+                }
+            }
+            if (typeof val === 'function') return val(params);
+            if (typeof val === 'string') return renderTemplate(val, params, 'common');
+            return val;
+        }
+    };
+}
+
+//# sourceMappingURL=createTranslate.js.map

package/lib/i18n/createTranslate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/i18n/createTranslate.ts"],"sourcesContent":["import { get } from '../objects/get';\nimport type { ObjectPathLike } from '../objects/parseObjectPath';\nimport { renderTemplate } from '../strings/renderTemplate';\n\nexport interface Translate<T extends object> {\n  /** Get/Set the language key */\n  locale(lang?: string): string;\n\n  /** Define the dict of translations for a language */\n  dict(lang: string, dict: T): void;\n\n  /** Get the dict of translations for a language */\n  dict(lang: string): T;\n\n  /** Retrieve a translation segment for the current language */\n  t<X extends Record<string, any> | any[]>(key: ObjectPathLike, params?: X, lang?: string): string;\n}\n\nexport function createTranslate<T extends object>(obj?: Record<string, T>): Translate<T> {\n  let locale = '';\n  const tree = obj || {};\n  // en-US -> en-US,en\n  const keyOfDict = (s: string | string[]) => {\n    if (Array.isArray(s)) {\n      return s;\n    }\n    const sp = s.split(/[_-]/);\n    if (sp.length > 1) {\n      return [s, sp[0]];\n    }\n    return [s];\n  };\n  return {\n    locale(lang) {\n      return (locale = lang || locale);\n    },\n\n    dict: ((lang, dict?) => {\n      if (dict) {\n        tree[lang] = Object.assign(tree[lang] || {}, dict);\n        return;\n      }\n      return tree[lang];\n    }) as Translate<T>['dict'],\n\n    t(key, params, lang) {\n      let val: any;\n      for (const k of keyOfDict(lang || locale)) {\n        val = get(tree[k], key, '');\n        if (val) {\n          break;\n        }\n      }\n      if (process.env.NODE_ENV === 'development') {\n        if (val == null) {\n          console.error(\n            `[Translate] Missing the \"${[].concat(key as any).join('.')}\" key within the \"${\n              lang || locale\n            }\" dictionary`,\n          );\n          return;\n        }\n      }\n      if (typeof val === 'function') return val(params);\n      if (typeof val === 'string') return renderTemplate(val, params, 'common');\n      return val;\n    },\n  };\n}\n"],"names":["get","renderTemplate","createTranslate","obj","locale","tree","keyOfDict","s","Array","isArray","sp","split","length","lang","dict","Object","assign","t","key","params","val","k","process","env","NODE_ENV","console","error","concat","join"],"mappings":"AAAA,SAASA,GAAG,QAAQ,iBAAiB;AAErC,SAASC,cAAc,QAAQ,4BAA4B;AAgB3D,OAAO,SAASC,gBAAkCC,GAAuB;IACvE,IAAIC,SAAS;IACb,MAAMC,OAAOF,OAAO,CAAC;IACrB,oBAAoB;IACpB,MAAMG,YAAY,CAACC;QACjB,IAAIC,MAAMC,OAAO,CAACF,IAAI;YACpB,OAAOA;QACT;QACA,MAAMG,KAAKH,EAAEI,KAAK,CAAC;QACnB,IAAID,GAAGE,MAAM,GAAG,GAAG;YACjB,OAAO;gBAACL;gBAAGG,EAAE,CAAC,EAAE;aAAC;QACnB;QACA,OAAO;YAACH;SAAE;IACZ;IACA,OAAO;QACLH,QAAOS,IAAI;YACT,OAAQT,SAASS,QAAQT;QAC3B;QAEAU,MAAO,CAACD,MAAMC;YACZ,IAAIA,MAAM;gBACRT,IAAI,CAACQ,KAAK,GAAGE,OAAOC,MAAM,CAACX,IAAI,CAACQ,KAAK,IAAI,CAAC,GAAGC;gBAC7C;YACF;YACA,OAAOT,IAAI,CAACQ,KAAK;QACnB;QAEAI,GAAEC,GAAG,EAAEC,MAAM,EAAEN,IAAI;YACjB,IAAIO;YACJ,KAAK,MAAMC,KAAKf,UAAUO,QAAQT,QAAS;gBACzCgB,MAAMpB,IAAIK,IAAI,CAACgB,EAAE,EAAEH,KAAK;gBACxB,IAAIE,KAAK;oBACP;gBACF;YACF;YACA,IAAIE,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;gBAC1C,IAAIJ,OAAO,MAAM;oBACfK,QAAQC,KAAK,CACX,CAAC,yBAAyB,EAAE,EAAE,CAACC,MAAM,CAACT,KAAYU,IAAI,CAAC,KAAK,kBAAkB,EAC5Ef,QAAQT,OACT,YAAY,CAAC;oBAEhB;gBACF;YACF;YACA,IAAI,OAAOgB,QAAQ,YAAY,OAAOA,IAAID;YAC1C,IAAI,OAAOC,QAAQ,UAAU,OAAOnB,eAAemB,KAAKD,QAAQ;YAChE,OAAOC;QACT;IACF;AACF"}

package/lib/index.js

@@ -0,0 +1,83 @@
+// arrays
+export { firstOfMaybeArray, lastOfMaybeArray, arrayOfMaybeArray, objectOfMaybeArray } from './arrays/MaybeArray.js';
+export { arrayFromAsync } from './arrays/arrayFromAsync.js';
+// object
+export { get } from './objects/get.js';
+export { set } from './objects/set.js';
+export { parseObjectPath } from './objects/parseObjectPath.js';
+export { merge } from './objects/merge/index.js';
+// async
+export { createLazyPromise } from './asyncs/createLazyPromise.js';
+export { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval.js';
+// async - iterator
+export { createAsyncIterator } from './asyncs/createAsyncIterator.js';
+export { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator.js';
+export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator.js';
+export { isIterator } from './asyncs/isIterator.js';
+export { sleep } from './asyncs/sleep.js';
+export { timeout, TimeoutError } from './asyncs/timeout.js';
+export { isPromise } from './asyncs/isPromise.js';
+// export * from './async/promiseOfCallback';
+// langs
+export { shallowEqual } from './langs/shallowEqual.js';
+export { deepEqual } from './langs/deepEqual.js';
+export { deepFreeze } from './langs/deepFreeze.js';
+export { classOf } from './langs/classOf.js';
+export { shallowClone } from './langs/shallowClone.js';
+export { isClass } from './langs/isClass.js';
+export { isDefined } from './langs/isDefined.js';
+export { isEmptyObject } from './langs/isEmptyObject.js';
+export { isPlainObject } from './langs/isPlainObject.js';
+export { parseBoolean } from './langs/parseBoolean.js';
+export { maybeFunction } from './langs/MaybeFunction.js';
+export { memoize } from './langs/memoize.js';
+export { AsyncCloser } from './langs/AsyncCloser.js';
+export { Closer } from './langs/Closer.js';
+export { isUUID } from './validations/isUUID.js';
+export { parseTimestamp } from './validations/parseTimestamp.js';
+// modules
+export { parseModuleId } from './modules/parseModuleId.js';
+export { isModule } from './modules/isModule.js';
+export { createLogger } from './logging/createLogger.js';
+export { createNoopLogger } from './logging/createNoopLogger.js';
+export { createChildLogger } from './logging/createChildLogger.js';
+// strings
+export { pascalCase, camelCase } from './strings/camelCase.js';
+export { renderTemplate } from './strings/renderTemplate.js';
+export { formatBytes } from './strings/formatBytes.js';
+// i18n
+export { createTranslate } from './i18n/createTranslate.js';
+// io
+export { isBuffer } from './io/isBuffer.js';
+export { isTransferable } from './io/isTransferable.js';
+export { ArrayBuffers } from './io/ArrayBuffers.js';
+export { Buffer } from './io/Buffer.js';
+// browser
+export { copy } from './browsers/copy.js';
+export { download } from './browsers/download.js';
+export { loadScripts, loadStyles } from './browsers/loaders.js';
+export { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer.js';
+// polyfills
+export { getGlobalThis } from './isomorphics/getGlobalThis.js';
+export { structuredClone } from './isomorphics/structuredClone.js';
+// crypto
+export { randomUUID } from './crypto/randomUUID.js';
+export { getRandomValues } from './crypto/getRandomValues.js';
+export { sha1, sha256, sha384, sha512, hmac } from './crypto/hashing.js';
+export { md5 } from './crypto/md5.js';
+export { hex } from './crypto/base.js';
+export { isULID, createULID, ulid, parseULID } from './crypto/ulid.js';
+export { PEM } from './crypto/pem/pem.js';
+// math
+export { createRandom } from './maths/random.js';
+export { clamp } from './maths/clamp.js';
+// network
+export { createFetchWith, createFetchWithLogging, dumpResponse, dumpRequest, createFetchWithRetry } from './fetch/index.js';
+// bundled
+export { default as ms } from './libs/ms.js';
+// error
+export { Errors, DetailError } from './errors/Errors.js';
+// http
+export { getHttpStatusText, isRetryableHttpStatus } from './http/HttpStatus.js';
+
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// arrays\nexport {\n  firstOfMaybeArray,\n  lastOfMaybeArray,\n  arrayOfMaybeArray,\n  objectOfMaybeArray,\n  type MaybeArray,\n} from './arrays/MaybeArray';\nexport { arrayFromAsync } from './arrays/arrayFromAsync';\n\n// object\nexport { get } from './objects/get';\nexport { set } from './objects/set';\nexport { parseObjectPath } from './objects/parseObjectPath';\nexport { merge, type MergeOptions } from './objects/merge';\n\n// async\nexport { createLazyPromise, type LazyPromise } from './asyncs/createLazyPromise';\nexport { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval';\nexport { type MaybePromise } from './asyncs/MaybePromise';\n// async - iterator\nexport { createAsyncIterator } from './asyncs/createAsyncIterator';\nexport { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator';\nexport { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator';\nexport { isIterator } from './asyncs/isIterator';\n\nexport { sleep } from './asyncs/sleep';\nexport { timeout, TimeoutError } from './asyncs/timeout';\nexport { isPromise } from './asyncs/isPromise';\n// export * from './async/promiseOfCallback';\n\n// langs\nexport { shallowEqual } from './langs/shallowEqual';\nexport { deepEqual } from './langs/deepEqual';\nexport { deepFreeze } from './langs/deepFreeze';\nexport { classOf } from './langs/classOf';\nexport { shallowClone } from './langs/shallowClone';\nexport { isClass } from './langs/isClass';\nexport { isDefined } from './langs/isDefined';\nexport { isEmptyObject } from './langs/isEmptyObject';\nexport { isPlainObject } from './langs/isPlainObject';\nexport { parseBoolean } from './langs/parseBoolean';\nexport { maybeFunction, type MaybeFunction } from './langs/MaybeFunction';\nexport { memoize } from './langs/memoize';\nexport { AsyncCloser } from './langs/AsyncCloser';\nexport { Closer } from './langs/Closer';\n\nexport { isUUID } from './validations/isUUID';\nexport { parseTimestamp } from './validations/parseTimestamp';\n\n// modules\nexport { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';\nexport { isModule, type Module } from './modules/isModule';\n\n// logging\nexport { type Logger, type LogLevel } from './logging/Logger';\nexport { createLogger } from './logging/createLogger';\nexport { createNoopLogger } from './logging/createNoopLogger';\nexport { createChildLogger } from './logging/createChildLogger';\n\n// strings\nexport { pascalCase, camelCase } from './strings/camelCase';\nexport { renderTemplate } from './strings/renderTemplate';\nexport { formatBytes } from './strings/formatBytes';\n\n// i18n\nexport { createTranslate } from './i18n/createTranslate';\n\n// io\nexport { isBuffer } from './io/isBuffer';\nexport { isTransferable } from './io/isTransferable';\nexport { ArrayBuffers } from './io/ArrayBuffers';\nexport { Buffer } from './io/Buffer';\nexport type { AbstractEncoding } from './io/AbstractEncoding';\n\n// browser\nexport { copy } from './browsers/copy';\nexport { download } from './browsers/download';\nexport { loadScripts, loadStyles } from './browsers/loaders';\nexport { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer';\n\n// polyfills\nexport { getGlobalThis } from './isomorphics/getGlobalThis';\nexport { structuredClone } from './isomorphics/structuredClone';\n\n// crypto\nexport { randomUUID } from './crypto/randomUUID';\nexport { getRandomValues } from './crypto/getRandomValues';\nexport { sha1, sha256, sha384, sha512, hmac, type DigestOptions } from './crypto/hashing';\nexport { md5 } from './crypto/md5';\nexport { hex } from './crypto/base';\nexport { isULID, createULID, ulid, parseULID } from './crypto/ulid';\nexport { PEM } from './crypto/pem/pem';\n\n// math\nexport { createRandom } from './maths/random';\nexport { clamp } from './maths/clamp';\n\n// network\nexport {\n  type FetchLike,\n  createFetchWith,\n  createFetchWithLogging,\n  dumpResponse,\n  dumpRequest,\n  createFetchWithRetry,\n  type FetchWithRetryOptions,\n} from './fetch';\n\n// bundled\nexport { default as ms } from './libs/ms';\n\n// error\nexport { Errors, DetailError, type ErrorDetail, type ErrorDetailInit } from './errors/Errors';\n// http\nexport { getHttpStatusText, isRetryableHttpStatus } from './http/HttpStatus';\n\nexport type * from './types';\n"],"names":["firstOfMaybeArray","lastOfMaybeArray","arrayOfMaybeArray","objectOfMaybeArray","arrayFromAsync","get","set","parseObjectPath","merge","createLazyPromise","setAsyncInterval","clearAsyncInterval","createAsyncIterator","firstOfAsyncIterator","nextOfAsyncIterator","isIterator","sleep","timeout","TimeoutError","isPromise","shallowEqual","deepEqual","deepFreeze","classOf","shallowClone","isClass","isDefined","isEmptyObject","isPlainObject","parseBoolean","maybeFunction","memoize","AsyncCloser","Closer","isUUID","parseTimestamp","parseModuleId","isModule","createLogger","createNoopLogger","createChildLogger","pascalCase","camelCase","renderTemplate","formatBytes","createTranslate","isBuffer","isTransferable","ArrayBuffers","Buffer","copy","download","loadScripts","loadStyles","getFileFromDataTransfer","getGlobalThis","structuredClone","randomUUID","getRandomValues","sha1","sha256","sha384","sha512","hmac","md5","hex","isULID","createULID","ulid","parseULID","PEM","createRandom","clamp","createFetchWith","createFetchWithLogging","dumpResponse","dumpRequest","createFetchWithRetry","default","ms","Errors","DetailError","getHttpStatusText","isRetryableHttpStatus"],"mappings":"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"}

package/lib/io/AbstractEncoding.js

@@ -0,0 +1,7 @@
+/**
+ * AbstractEncoding contract
+ *
+ * @see https://github.com/mafintosh/abstract-encoding
+ */ export { };
+
+//# sourceMappingURL=AbstractEncoding.js.map

package/lib/io/AbstractEncoding.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/io/AbstractEncoding.ts"],"sourcesContent":["/**\n * AbstractEncoding contract\n *\n * @see https://github.com/mafintosh/abstract-encoding\n */\nexport interface AbstractEncoding<T> {\n  /**\n   * encode a value to a buffer\n   */\n  encode(data: T, buffer?: ArrayBuffer, offset?: number): BufferSource;\n\n  /**\n   * decode data from buffer\n   */\n  decode(buffer: BufferSource, start?: number, end?: number): T;\n\n  /**\n   * byteLength of data\n   */\n  byteLength?: (data: T) => number;\n}\n"],"names":[],"mappings":"AAAA;;;;CAIC,GACD,WAeC"}

package/lib/io/ArrayBuffer.test-d.js

@@ -0,0 +1,7 @@
+import { expectTypeOf, test } from 'vitest';
+import { ArrayBuffers } from './ArrayBuffers.js';
+test('my types work properly', ()=>{
+    expectTypeOf(ArrayBuffers.asView(Buffer, new Uint8Array())).toMatchTypeOf();
+});
+
+//# sourceMappingURL=ArrayBuffer.test-d.js.map

package/lib/io/ArrayBuffer.test-d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/io/ArrayBuffer.test-d.ts"],"sourcesContent":["import { expectTypeOf, test } from 'vitest';\nimport { ArrayBuffers } from './ArrayBuffers';\n\ntest('my types work properly', () => {\n  expectTypeOf(ArrayBuffers.asView(Buffer, new Uint8Array())).toMatchTypeOf<Buffer>();\n});\n"],"names":["expectTypeOf","test","ArrayBuffers","asView","Buffer","Uint8Array","toMatchTypeOf"],"mappings":"AAAA,SAASA,YAAY,EAAEC,IAAI,QAAQ,SAAS;AAC5C,SAASC,YAAY,QAAQ,iBAAiB;AAE9CD,KAAK,0BAA0B;IAC7BD,aAAaE,aAAaC,MAAM,CAACC,QAAQ,IAAIC,eAAeC,aAAa;AAC3E"}

package/lib/io/ArrayBuffers.js

@@ -0,0 +1,210 @@
+import { getGlobalThis } from '../isomorphics/getGlobalThis.js';
+import { classOf } from '../langs/classOf.js';
+import { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64.js';
+import { isBuffer } from './isBuffer.js';
+export class ArrayBuffers {
+    static #nativeBufferAllowed = true;
+    static #isBufferAvailable;
+    static isNativeBufferAvailable() {
+        // eslint-disable-next-line no-return-assign
+        return this.#isBufferAvailable ??= !getGlobalThis().Buffer?.isPollyfill?.();
+    }
+    static isNativeBufferAllowed() {
+        return this.#nativeBufferAllowed && this.#isBufferAvailable;
+    }
+    static setNativeBufferAllowed(v) {
+        this.#nativeBufferAllowed = v;
+    }
+    static isArrayBuffer = (v)=>{
+        return v instanceof ArrayBuffer;
+    };
+    static slice = (o, start, end)=>{
+        // NodeJS Buffer slice is not the same as UInt8Array slice
+        // https://nodejs.org/api/buffer.html#bufslicestart-end
+        if (isBuffer(o)) {
+            return Uint8Array.prototype.slice.call(o, start, end);
+        }
+        return o.slice(start, end);
+    };
+    static asView = (TypedArray, v, byteOffset, byteLength)=>{
+        if (v instanceof TypedArray && (byteOffset ?? 0) === 0 && byteLength === undefined) {
+            return v;
+        }
+        if (ArrayBuffer.isView(v) || isBuffer(v)) {
+            if (ArrayBuffers.isNativeBufferAllowed() && TypedArray === Buffer) {
+                // new Buffer() is deprecated
+                return Buffer.from(v.buffer, byteOffset, byteLength);
+            }
+            return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength);
+        }
+        return new TypedArray(v, byteOffset, byteLength);
+    };
+    static toString = (buf, encoding = 'utf8')=>{
+        // 'ascii'  'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'
+        if (typeof buf === 'string') {
+            switch(encoding){
+                case 'base64':
+                    return btoa(buf);
+                case 'utf-8':
+                case 'utf8':
+                    return buf;
+                default:
+                    throw new Error(`[ArrayBuffers.toString] Unsupported encoding for string: ${encoding}`);
+            }
+        }
+        if (ArrayBuffers.isNativeBufferAllowed()) {
+            return Buffer.from(ArrayBuffers.asView(Uint8Array, buf)).toString(encoding);
+        }
+        // reference
+        // https://github.com/feross/buffer/blob/master/index.js
+        switch(encoding){
+            case 'hex':
+                {
+                    const view = ArrayBuffers.asView(Uint8Array, buf);
+                    return [
+                        ...view
+                    ].map((b)=>hexLookupTable[b]).join('');
+                }
+            case 'base64':
+                {
+                    return encodeArrayBufferToBase64(ArrayBuffers.asView(Uint8Array, buf));
+                }
+            case 'utf8':
+            // falls through
+            case 'utf-8':
+                return new TextDecoder().decode(buf);
+            case 'ascii':
+                {
+                    const view = ArrayBuffers.asView(Uint8Array, buf);
+                    return String.fromCharCode(...view.map((v)=>v & 0x7f));
+                }
+            case 'latin1':
+            // falls through
+            case 'binary':
+                {
+                    const view = ArrayBuffers.asView(Uint8Array, buf);
+                    return String.fromCharCode(...view);
+                }
+            case 'ucs2':
+            // falls through
+            case 'ucs-2':
+            // case 'utf-16le':
+            // falls through
+            case 'utf16le':
+                {
+                    const view = ArrayBuffers.asView(Uint8Array, buf);
+                    let res = '';
+                    // If length is odd, the last 8 bits must be ignored (same as node.js)
+                    for(let i = 0; i < view.length - 1; i += 2){
+                        res += String.fromCharCode(view[i] + view[i + 1] * 256);
+                    }
+                    return res;
+                }
+            default:
+                throw new Error(`[ArrayBuffers.toString] Unknown encoding: ${encoding}`);
+        }
+    };
+    static toJSON = (v, reviver)=>{
+        return JSON.parse(ArrayBuffers.toString(v), reviver);
+    };
+    static alloc = (size, fill, encoding)=>{
+        if (fill !== undefined) {
+            if (typeof fill === 'number') {
+                return new Uint8Array(size).fill(fill);
+            }
+            // as cast
+            // https://stackoverflow.com/questions/73994091
+            return ArrayBuffers.asView(Uint8Array, ArrayBuffers.from(fill, encoding)).slice(0, size);
+        }
+        return new ArrayBuffer(size);
+    };
+    static from = (v, encoding = 'utf8')=>{
+        if (!v) {
+            return new ArrayBuffer(0);
+        }
+        if (typeof v === 'string') {
+            if (ArrayBuffers.isNativeBufferAllowed()) {
+                return Buffer.from(v, encoding);
+            }
+            switch(encoding){
+                case 'utf-8':
+                // falls through
+                case 'utf8':
+                    return new TextEncoder().encode(v).buffer;
+                case 'base64':
+                    // replaceAll need higher version of nodejs
+                    return decodeBase64ToArrayBuffer(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));
+                // error in nodejs 18
+                // return Uint8Array.from(atob(v.replace(/[^0-9a-zA-Z=+/_ \r\n]/g, '')), (c) => c.charCodeAt(0));
+                default:
+                    throw new Error(`[ArrayBuffers.from] Unknown encoding: ${encoding}`);
+            }
+        }
+        if (v instanceof ArrayBuffer) {
+            return v;
+        }
+        // lost length
+        if (ArrayBuffer.isView(v) || isBuffer(v)) {
+            if (v.byteOffset !== 0) {
+                // return v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength)
+                throw new Error('ArrayBuffers.from do not support view with offset');
+            }
+            return v.buffer;
+        }
+        if (Array.isArray(v)) {
+            return new Uint8Array(v);
+        }
+        const type = classOf(v);
+        throw new TypeError(`ArrayBuffers.from unsupported type ${type}`);
+    };
+    static isEncoding = (encoding)=>{
+        switch(String(encoding).toLowerCase()){
+            case 'hex':
+            case 'utf8':
+            case 'utf-8':
+            case 'ascii':
+            case 'latin1':
+            case 'binary':
+            case 'base64':
+            case 'ucs2':
+            case 'ucs-2':
+            case 'utf16le':
+                // case 'utf-16le':
+                return true;
+            default:
+                return false;
+        }
+    };
+    static concat = (buffers, result, offset = 0)=>{
+        // https://stackoverflow.com/questions/10786128/appending-arraybuffers
+        const length = buffers.reduce((a, b)=>a + b.byteLength, 0);
+        const r = result ? new Uint8Array(result) : new Uint8Array(length);
+        for (const buffer of buffers){
+            if (!buffer?.byteLength) continue;
+            let n;
+            if (buffer instanceof ArrayBuffer) {
+                n = new Uint8Array(buffer);
+            } else if (ArrayBuffer.isView(buffer)) {
+                n = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            } else {
+                throw new Error(`ArrayBuffers.concat unsupported type ${classOf(buffer)}`);
+            }
+            r.set(n, offset);
+            offset += buffer.byteLength;
+        }
+        return r.buffer;
+    };
+}
+const hexLookupTable = function() {
+    const alphabet = '0123456789abcdef';
+    const table = new Array(256);
+    for(let i = 0; i < 16; ++i){
+        const i16 = i * 16;
+        for(let j = 0; j < 16; ++j){
+            table[i16 + j] = alphabet[i] + alphabet[j];
+        }
+    }
+    return table;
+}();
+
+//# sourceMappingURL=ArrayBuffers.js.map

package/lib/io/ArrayBuffers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/io/ArrayBuffers.ts"],"sourcesContent":["import { getGlobalThis } from '../isomorphics/getGlobalThis';\nimport { classOf } from '../langs/classOf';\nimport { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64';\nimport { isBuffer } from './isBuffer';\n\n/**\n * Various utils to work with {@link ArrayBuffer}\n */\nexport interface ArrayBuffers {\n  /**\n   * isArrayBuffer check if the given value is an {@link ArrayBuffer}\n   */\n  isArrayBuffer(v: any): v is ArrayBuffer;\n\n  /**\n   * slice the given view with the given offset and length, will handle the {@link Buffer} as well\n   *\n   * @see {@link https://nodejs.org/api/buffer.html#bufslicestart-end Buffer.slice}\n   */\n  slice<T extends ArrayBufferView>(o: T, start?: number, end?: number): T;\n\n  /**\n   * asView convert the given value to given {@link TypedArray} view\n   *\n   * TypedArray can be {@link Buffer}, will avoid copy\n   */\n  asView<C extends ArrayBufferViewConstructor<unknown>>(\n    TypedArray: C,\n    v: BufferSource,\n    byteOffset?: number,\n    byteLength?: number,\n  ): InstanceType<C>;\n\n  /**\n   * toString convert the given {@link BufferSource} to string\n   */\n  toString(v: BufferSource | string, encoding?: ToStringEncoding): string;\n\n  /**\n   * Returns true if encoding is the name of a supported character encoding, or false otherwise.\n   */\n  isEncoding(v?: string): v is ToStringEncoding;\n\n  toJSON<T = any>(v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any): T;\n\n  /**\n   * from convert the given value to {@link ArrayBuffer}\n   */\n  from(v: string | BufferSource, encoding?: ToStringEncoding): ArrayBuffer;\n\n  /**\n   * concat the given {@link BufferSource} to a new {@link ArrayBuffer}\n   */\n  concat(buffers: Array<BufferSource>, result?: ArrayBuffer, offset?: number): ArrayBuffer;\n}\n\ntype ToStringEncoding =\n  | 'ascii'\n  | 'utf16le'\n  // | 'utf-16le'\n  | 'ucs2'\n  | 'ucs-2'\n  | 'base64'\n  | 'base64url'\n  | 'latin1'\n  | 'binary'\n  | 'utf8'\n  | 'utf-8'\n  | 'hex';\n\nexport class ArrayBuffers {\n  static #nativeBufferAllowed: boolean = true;\n  static #isBufferAvailable: undefined | boolean;\n\n  static isNativeBufferAvailable() {\n    // eslint-disable-next-line no-return-assign\n    return (this.#isBufferAvailable ??= !(getGlobalThis().Buffer as any)?.isPollyfill?.());\n  }\n\n  static isNativeBufferAllowed() {\n    return this.#nativeBufferAllowed && this.#isBufferAvailable;\n  }\n\n  static setNativeBufferAllowed(v: boolean) {\n    this.#nativeBufferAllowed = v;\n  }\n\n  static isArrayBuffer = (v: any): v is ArrayBuffer => {\n    return v instanceof ArrayBuffer;\n  };\n\n  static slice = (o: TypedArray, start?: number, end?: number) => {\n    // NodeJS Buffer slice is not the same as UInt8Array slice\n    // https://nodejs.org/api/buffer.html#bufslicestart-end\n    if (isBuffer(o)) {\n      return Uint8Array.prototype.slice.call(o, start, end);\n    }\n    return o.slice(start, end);\n  };\n\n  static asView = <C extends ArrayBufferViewConstructor<unknown>, I extends InstanceType<C>>(\n    TypedArray: C,\n    v: BufferSource,\n    byteOffset?: number,\n    byteLength?: number,\n  ): I => {\n    if (v instanceof TypedArray && (byteOffset ?? 0) === 0 && byteLength === undefined) {\n      return v as I;\n    }\n    if (ArrayBuffer.isView(v) || isBuffer(v)) {\n      if (ArrayBuffers.isNativeBufferAllowed() && (TypedArray as any) === Buffer) {\n        // new Buffer() is deprecated\n        return Buffer.from(v.buffer, byteOffset, byteLength) as I;\n      }\n      return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength) as I;\n    }\n    return new TypedArray(v, byteOffset, byteLength) as I;\n  };\n\n  static toString = (buf: BufferSource | string, encoding: ToStringEncoding = 'utf8') => {\n    // 'ascii'  'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'\n    if (typeof buf === 'string') {\n      switch (encoding) {\n        case 'base64':\n          return btoa(buf);\n        case 'utf-8':\n        case 'utf8':\n          return buf;\n        default:\n          throw new Error(`[ArrayBuffers.toString] Unsupported encoding for string: ${encoding}`);\n      }\n    }\n    if (ArrayBuffers.isNativeBufferAllowed()) {\n      return Buffer.from(ArrayBuffers.asView(Uint8Array, buf)).toString(encoding);\n    }\n    // reference\n    // https://github.com/feross/buffer/blob/master/index.js\n    switch (encoding) {\n      case 'hex': {\n        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);\n        return [...view].map((b) => hexLookupTable[b]).join('');\n      }\n      case 'base64': {\n        return encodeArrayBufferToBase64(ArrayBuffers.asView(Uint8Array, buf));\n      }\n      case 'utf8':\n      // falls through\n      case 'utf-8':\n        return new TextDecoder().decode(buf as any);\n      case 'ascii': {\n        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);\n        return String.fromCharCode(...view.map((v) => v & 0x7f));\n      }\n      case 'latin1':\n      // falls through\n      case 'binary': {\n        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);\n        return String.fromCharCode(...view);\n      }\n      case 'ucs2':\n      // falls through\n      case 'ucs-2':\n      // case 'utf-16le':\n      // falls through\n      case 'utf16le': {\n        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);\n        let res = '';\n        // If length is odd, the last 8 bits must be ignored (same as node.js)\n        for (let i = 0; i < view.length - 1; i += 2) {\n          res += String.fromCharCode(view[i] + view[i + 1] * 256);\n        }\n        return res;\n      }\n      default:\n        throw new Error(`[ArrayBuffers.toString] Unknown encoding: ${encoding}`);\n    }\n  };\n\n  static toJSON = (v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any) => {\n    return JSON.parse(ArrayBuffers.toString(v), reviver);\n  };\n\n  static alloc = (size: number, fill?: string | number, encoding?: ToStringEncoding) => {\n    if (fill !== undefined) {\n      if (typeof fill === 'number') {\n        return new Uint8Array(size).fill(fill);\n      }\n      // as cast\n      // https://stackoverflow.com/questions/73994091\n      return ArrayBuffers.asView(Uint8Array, ArrayBuffers.from(fill, encoding)).slice(0, size);\n    }\n    return new ArrayBuffer(size);\n  };\n\n  static from = (\n    v: string | BufferSource | ArrayLike<number> | Iterable<number>,\n    encoding: ToStringEncoding = 'utf8',\n  ): BufferSource => {\n    if (!v) {\n      return new ArrayBuffer(0);\n    }\n    if (typeof v === 'string') {\n      if (ArrayBuffers.isNativeBufferAllowed()) {\n        return Buffer.from(v, encoding);\n      }\n\n      switch (encoding) {\n        case 'utf-8':\n        // falls through\n        case 'utf8':\n          return new TextEncoder().encode(v).buffer;\n        case 'base64':\n          // replaceAll need higher version of nodejs\n          return decodeBase64ToArrayBuffer(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));\n        // error in nodejs 18\n        // return Uint8Array.from(atob(v.replace(/[^0-9a-zA-Z=+/_ \\r\\n]/g, '')), (c) => c.charCodeAt(0));\n        default:\n          throw new Error(`[ArrayBuffers.from] Unknown encoding: ${encoding}`);\n      }\n    }\n    if (v instanceof ArrayBuffer) {\n      return v;\n    }\n    // lost length\n    if (ArrayBuffer.isView(v) || isBuffer(v)) {\n      if (v.byteOffset !== 0) {\n        // return v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength)\n        throw new Error('ArrayBuffers.from do not support view with offset');\n      }\n      return v.buffer;\n    }\n    if (Array.isArray(v)) {\n      return new Uint8Array(v);\n    }\n    const type = classOf(v);\n    throw new TypeError(`ArrayBuffers.from unsupported type ${type}`);\n  };\n\n  static isEncoding = (encoding?: string) => {\n    switch (String(encoding).toLowerCase()) {\n      case 'hex':\n      case 'utf8':\n      case 'utf-8':\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n      case 'base64':\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n        // case 'utf-16le':\n        return true;\n      default:\n        return false;\n    }\n  };\n\n  static concat = (buffers: Array<BufferSource>, result?: ArrayBuffer, offset = 0) => {\n    // https://stackoverflow.com/questions/10786128/appending-arraybuffers\n\n    const length = buffers.reduce((a, b) => a + b.byteLength, 0);\n    const r = result ? new Uint8Array(result) : new Uint8Array(length);\n    for (const buffer of buffers) {\n      if (!buffer?.byteLength) continue;\n      let n: Uint8Array;\n      if (buffer instanceof ArrayBuffer) {\n        n = new Uint8Array(buffer);\n      } else if (ArrayBuffer.isView(buffer)) {\n        n = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n      } else {\n        throw new Error(`ArrayBuffers.concat unsupported type ${classOf(buffer)}`);\n      }\n      r.set(n, offset);\n      offset += buffer.byteLength;\n    }\n    return r.buffer;\n  };\n}\n\nexport type TypedArray =\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | BigUint64Array\n  | BigInt64Array\n  | Float32Array\n  | Float64Array;\n\ntype ArrayBufferViewConstructor<T> = new (buffer: ArrayBufferLike, byteOffset?: number, byteLength?: number) => T;\n\nconst hexLookupTable = (function () {\n  const alphabet = '0123456789abcdef';\n  const table = new Array(256);\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16;\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j];\n    }\n  }\n  return table;\n})();\n"],"names":["getGlobalThis","classOf","decodeBase64ToArrayBuffer","encodeArrayBufferToBase64","isBuffer","ArrayBuffers","nativeBufferAllowed","isBufferAvailable","isNativeBufferAvailable","Buffer","isPollyfill","isNativeBufferAllowed","setNativeBufferAllowed","v","isArrayBuffer","ArrayBuffer","slice","o","start","end","Uint8Array","prototype","call","asView","TypedArray","byteOffset","byteLength","undefined","isView","from","buffer","toString","buf","encoding","btoa","Error","view","map","b","hexLookupTable","join","TextDecoder","decode","String","fromCharCode","res","i","length","toJSON","reviver","JSON","parse","alloc","size","fill","TextEncoder","encode","replace","Array","isArray","type","TypeError","isEncoding","toLowerCase","concat","buffers","result","offset","reduce","a","r","n","set","alphabet","table","i16","j"],"mappings":"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"}

package/lib/io/Buffer.js

@@ -0,0 +1,25 @@
+import { ArrayBuffers } from './ArrayBuffers.js';
+import { isBuffer } from './isBuffer.js';
+/**
+ * Buffer is a polyfill version of NodeJS Buffer
+ */ export class Buffer extends Uint8Array {
+    // constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {
+    //   super(buffer, byteOffset, length);
+    // }
+    static get isPolyfill() {
+        return true;
+    }
+    static isBuffer(v) {
+        return v instanceof Buffer || isBuffer(v);
+    }
+    static from(array, arg2) {
+        // todo mapfn
+        return new Buffer(ArrayBuffers.from(array, arg2));
+    }
+    static isEncoding = ArrayBuffers.isEncoding;
+    toString(encoding) {
+        return ArrayBuffers.toString(this, encoding);
+    }
+}
+
+//# sourceMappingURL=Buffer.js.map

package/lib/io/Buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/io/Buffer.ts"],"sourcesContent":["import { ArrayBuffers } from './ArrayBuffers';\nimport { isBuffer } from './isBuffer';\n\n/**\n * Buffer is a polyfill version of NodeJS Buffer\n */\nexport class Buffer extends Uint8Array {\n  // constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {\n  //   super(buffer, byteOffset, length);\n  // }\n\n  static get isPolyfill() {\n    return true;\n  }\n\n  static isBuffer(v: any): v is Buffer {\n    return v instanceof Buffer || isBuffer(v);\n  }\n\n  static from(array: string | BufferSource | ArrayLike<number> | Iterable<number>, arg2?: any): Buffer {\n    // todo mapfn\n    return new Buffer(ArrayBuffers.from(array, arg2) as ArrayBuffer);\n  }\n\n  static isEncoding = ArrayBuffers.isEncoding;\n\n  toString(encoding?: string): string {\n    return ArrayBuffers.toString(this, encoding as any);\n  }\n}\n"],"names":["ArrayBuffers","isBuffer","Buffer","Uint8Array","isPolyfill","v","from","array","arg2","isEncoding","toString","encoding"],"mappings":"AAAA,SAASA,YAAY,QAAQ,iBAAiB;AAC9C,SAASC,QAAQ,QAAQ,aAAa;AAEtC;;CAEC,GACD,OAAO,MAAMC,eAAeC;IAC1B,+EAA+E;IAC/E,uCAAuC;IACvC,IAAI;IAEJ,WAAWC,aAAa;QACtB,OAAO;IACT;IAEA,OAAOH,SAASI,CAAM,EAAe;QACnC,OAAOA,aAAaH,UAAUD,SAASI;IACzC;IAEA,OAAOC,KAAKC,KAAmE,EAAEC,IAAU,EAAU;QACnG,aAAa;QACb,OAAO,IAAIN,OAAOF,aAAaM,IAAI,CAACC,OAAOC;IAC7C;IAEA,OAAOC,aAAaT,aAAaS,UAAU,CAAC;IAE5CC,SAASC,QAAiB,EAAU;QAClC,OAAOX,aAAaU,QAAQ,CAAC,IAAI,EAAEC;IACrC;AACF"}

package/lib/io/Bytes.js

@@ -0,0 +1,51 @@
+const objectToString = Object.prototype.toString;
+const uint8ArrayStringified = '[object Uint8Array]';
+/**
+ * Utils for UInt8Array
+ *
+ * @see https://github.com/sindresorhus/uint8array-extras/blob/main/index.js
+ */ export class Bytes {
+    static #decoder = new globalThis.TextDecoder();
+    static isUint8Array(value) {
+        if (!value) {
+            return false;
+        }
+        if (value.constructor === Uint8Array) {
+            return true;
+        }
+        return objectToString.call(value) === uint8ArrayStringified;
+    }
+    static require(value) {
+        if (!this.isUint8Array(value)) {
+            throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
+        }
+        return value;
+    }
+    static toUint8Array(value) {
+        if (value instanceof ArrayBuffer) {
+            return new Uint8Array(value);
+        }
+        if (ArrayBuffer.isView(value)) {
+            return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+        }
+        throw new TypeError(`Unsupported value, got \`${typeof value}\`.`);
+    }
+    static concat(arrays, totalLength) {
+        if (arrays.length === 0) {
+            return new Uint8Array(0);
+        }
+        totalLength ??= arrays.reduce((accumulator, currentValue)=>accumulator + currentValue.length, 0);
+        const returnValue = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const array of arrays){
+            returnValue.set(this.require(array), offset);
+            offset += array.length;
+        }
+        return returnValue;
+    }
+    static toString(value) {
+        return this.#decoder.decode(value);
+    }
+}
+
+//# sourceMappingURL=Bytes.js.map

package/lib/io/Bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/io/Bytes.ts"],"sourcesContent":["const objectToString = Object.prototype.toString;\nconst uint8ArrayStringified = '[object Uint8Array]';\n\n/**\n * Utils for UInt8Array\n *\n * @see https://github.com/sindresorhus/uint8array-extras/blob/main/index.js\n */\nexport class Bytes {\n  static #decoder = new globalThis.TextDecoder();\n\n  static isUint8Array(value: any): value is Uint8Array {\n    if (!value) {\n      return false;\n    }\n\n    if (value.constructor === Uint8Array) {\n      return true;\n    }\n\n    return objectToString.call(value) === uint8ArrayStringified;\n  }\n\n  static require(value: any): Uint8Array {\n    if (!this.isUint8Array(value)) {\n      throw new TypeError(`Expected \\`Uint8Array\\`, got \\`${typeof value}\\``);\n    }\n    return value;\n  }\n\n  static toUint8Array(value: ArrayBuffer | ArrayBufferView): Uint8Array {\n    if (value instanceof ArrayBuffer) {\n      return new Uint8Array(value);\n    }\n\n    if (ArrayBuffer.isView(value)) {\n      return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n    }\n\n    throw new TypeError(`Unsupported value, got \\`${typeof value}\\`.`);\n  }\n\n  static concat(arrays: Uint8Array[], totalLength: number): Uint8Array {\n    if (arrays.length === 0) {\n      return new Uint8Array(0);\n    }\n\n    totalLength ??= arrays.reduce((accumulator, currentValue) => accumulator + currentValue.length, 0);\n\n    const returnValue = new Uint8Array(totalLength);\n\n    let offset = 0;\n    for (const array of arrays) {\n      returnValue.set(this.require(array), offset);\n      offset += array.length;\n    }\n\n    return returnValue;\n  }\n\n  static toString(value: Uint8Array) {\n    return this.#decoder.decode(value);\n  }\n}\n"],"names":["objectToString","Object","prototype","toString","uint8ArrayStringified","Bytes","decoder","globalThis","TextDecoder","isUint8Array","value","constructor","Uint8Array","call","require","TypeError","toUint8Array","ArrayBuffer","isView","buffer","byteOffset","byteLength","concat","arrays","totalLength","length","reduce","accumulator","currentValue","returnValue","offset","array","set","decode"],"mappings":"AAAA,MAAMA,iBAAiBC,OAAOC,SAAS,CAACC,QAAQ;AAChD,MAAMC,wBAAwB;AAE9B;;;;CAIC,GACD,OAAO,MAAMC;IACX,OAAO,CAACC,OAAO,GAAG,IAAIC,WAAWC,WAAW,GAAG;IAE/C,OAAOC,aAAaC,KAAU,EAAuB;QACnD,IAAI,CAACA,OAAO;YACV,OAAO;QACT;QAEA,IAAIA,MAAMC,WAAW,KAAKC,YAAY;YACpC,OAAO;QACT;QAEA,OAAOZ,eAAea,IAAI,CAACH,WAAWN;IACxC;IAEA,OAAOU,QAAQJ,KAAU,EAAc;QACrC,IAAI,CAAC,IAAI,CAACD,YAAY,CAACC,QAAQ;YAC7B,MAAM,IAAIK,UAAU,CAAC,+BAA+B,EAAE,OAAOL,MAAM,EAAE,CAAC;QACxE;QACA,OAAOA;IACT;IAEA,OAAOM,aAAaN,KAAoC,EAAc;QACpE,IAAIA,iBAAiBO,aAAa;YAChC,OAAO,IAAIL,WAAWF;QACxB;QAEA,IAAIO,YAAYC,MAAM,CAACR,QAAQ;YAC7B,OAAO,IAAIE,WAAWF,MAAMS,MAAM,EAAET,MAAMU,UAAU,EAAEV,MAAMW,UAAU;QACxE;QAEA,MAAM,IAAIN,UAAU,CAAC,yBAAyB,EAAE,OAAOL,MAAM,GAAG,CAAC;IACnE;IAEA,OAAOY,OAAOC,MAAoB,EAAEC,WAAmB,EAAc;QACnE,IAAID,OAAOE,MAAM,KAAK,GAAG;YACvB,OAAO,IAAIb,WAAW;QACxB;QAEAY,gBAAgBD,OAAOG,MAAM,CAAC,CAACC,aAAaC,eAAiBD,cAAcC,aAAaH,MAAM,EAAE;QAEhG,MAAMI,cAAc,IAAIjB,WAAWY;QAEnC,IAAIM,SAAS;QACb,KAAK,MAAMC,SAASR,OAAQ;YAC1BM,YAAYG,GAAG,CAAC,IAAI,CAAClB,OAAO,CAACiB,QAAQD;YACrCA,UAAUC,MAAMN,MAAM;QACxB;QAEA,OAAOI;IACT;IAEA,OAAO1B,SAASO,KAAiB,EAAE;QACjC,OAAO,IAAI,CAAC,CAACJ,OAAO,CAAC2B,MAAM,CAACvB;IAC9B;AACF"}