@empellio/currency-utils
Version:
Lightweight TypeScript utilities for currency formatting and conversions using live exchange rates from public APIs (ECB, CNB, exchangerate.host), with caching and offline fallback.
1,197 lines (1,195 loc) • 276 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/data-uri-to-buffer/dist/index.js
function dataUriToBuffer(uri) {
if (!/^data:/i.test(uri)) {
throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
}
uri = uri.replace(/\r?\n/g, "");
const firstComma = uri.indexOf(",");
if (firstComma === -1 || firstComma <= 4) {
throw new TypeError("malformed data: URI");
}
const meta = uri.substring(5, firstComma).split(";");
let charset = "";
let base64 = false;
const type = meta[0] || "text/plain";
let typeFull = type;
for (let i2 = 1; i2 < meta.length; i2++) {
if (meta[i2] === "base64") {
base64 = true;
} else if (meta[i2]) {
typeFull += `;${meta[i2]}`;
if (meta[i2].indexOf("charset=") === 0) {
charset = meta[i2].substring(8);
}
}
}
if (!meta[0] && !charset.length) {
typeFull += ";charset=US-ASCII";
charset = "US-ASCII";
}
const encoding = base64 ? "base64" : "ascii";
const data = unescape(uri.substring(firstComma + 1));
const buffer = Buffer.from(data, encoding);
buffer.type = type;
buffer.typeFull = typeFull;
buffer.charset = charset;
return buffer;
}
var dist_default;
var init_dist = __esm({
"node_modules/data-uri-to-buffer/dist/index.js"() {
"use strict";
dist_default = dataUriToBuffer;
}
});
// node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
var require_ponyfill_es2018 = __commonJS({
"node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports2, module2) {
"use strict";
(function(global2, factory) {
typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.WebStreamsPolyfill = {}));
})(exports2, function(exports3) {
"use strict";
function noop2() {
return void 0;
}
function typeIsObject(x2) {
return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
}
const rethrowAssertionErrorRejection = noop2;
function setFunctionName(fn, name) {
try {
Object.defineProperty(fn, "name", {
value: name,
configurable: true
});
} catch (_a2) {
}
}
const originalPromise = Promise;
const originalPromiseThen = Promise.prototype.then;
const originalPromiseReject = Promise.reject.bind(originalPromise);
function newPromise(executor) {
return new originalPromise(executor);
}
function promiseResolvedWith(value) {
return newPromise((resolve) => resolve(value));
}
function promiseRejectedWith(reason) {
return originalPromiseReject(reason);
}
function PerformPromiseThen(promise, onFulfilled, onRejected) {
return originalPromiseThen.call(promise, onFulfilled, onRejected);
}
function uponPromise(promise, onFulfilled, onRejected) {
PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), void 0, rethrowAssertionErrorRejection);
}
function uponFulfillment(promise, onFulfilled) {
uponPromise(promise, onFulfilled);
}
function uponRejection(promise, onRejected) {
uponPromise(promise, void 0, onRejected);
}
function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
}
function setPromiseIsHandledToTrue(promise) {
PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection);
}
let _queueMicrotask = (callback) => {
if (typeof queueMicrotask === "function") {
_queueMicrotask = queueMicrotask;
} else {
const resolvedPromise = promiseResolvedWith(void 0);
_queueMicrotask = (cb) => PerformPromiseThen(resolvedPromise, cb);
}
return _queueMicrotask(callback);
};
function reflectCall(F2, V, args) {
if (typeof F2 !== "function") {
throw new TypeError("Argument is not a function");
}
return Function.prototype.apply.call(F2, V, args);
}
function promiseCall(F2, V, args) {
try {
return promiseResolvedWith(reflectCall(F2, V, args));
} catch (value) {
return promiseRejectedWith(value);
}
}
const QUEUE_MAX_ARRAY_SIZE = 16384;
class SimpleQueue {
constructor() {
this._cursor = 0;
this._size = 0;
this._front = {
_elements: [],
_next: void 0
};
this._back = this._front;
this._cursor = 0;
this._size = 0;
}
get length() {
return this._size;
}
// For exception safety, this method is structured in order:
// 1. Read state
// 2. Calculate required state mutations
// 3. Perform state mutations
push(element) {
const oldBack = this._back;
let newBack = oldBack;
if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {
newBack = {
_elements: [],
_next: void 0
};
}
oldBack._elements.push(element);
if (newBack !== oldBack) {
this._back = newBack;
oldBack._next = newBack;
}
++this._size;
}
// Like push(), shift() follows the read -> calculate -> mutate pattern for
// exception safety.
shift() {
const oldFront = this._front;
let newFront = oldFront;
const oldCursor = this._cursor;
let newCursor = oldCursor + 1;
const elements = oldFront._elements;
const element = elements[oldCursor];
if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
newFront = oldFront._next;
newCursor = 0;
}
--this._size;
this._cursor = newCursor;
if (oldFront !== newFront) {
this._front = newFront;
}
elements[oldCursor] = void 0;
return element;
}
// The tricky thing about forEach() is that it can be called
// re-entrantly. The queue may be mutated inside the callback. It is easy to
// see that push() within the callback has no negative effects since the end
// of the queue is checked for on every iteration. If shift() is called
// repeatedly within the callback then the next iteration may return an
// element that has been removed. In this case the callback will be called
// with undefined values until we either "catch up" with elements that still
// exist or reach the back of the queue.
forEach(callback) {
let i2 = this._cursor;
let node = this._front;
let elements = node._elements;
while (i2 !== elements.length || node._next !== void 0) {
if (i2 === elements.length) {
node = node._next;
elements = node._elements;
i2 = 0;
if (elements.length === 0) {
break;
}
}
callback(elements[i2]);
++i2;
}
}
// Return the element that would be returned if shift() was called now,
// without modifying the queue.
peek() {
const front = this._front;
const cursor = this._cursor;
return front._elements[cursor];
}
}
const AbortSteps = Symbol("[[AbortSteps]]");
const ErrorSteps = Symbol("[[ErrorSteps]]");
const CancelSteps = Symbol("[[CancelSteps]]");
const PullSteps = Symbol("[[PullSteps]]");
const ReleaseSteps = Symbol("[[ReleaseSteps]]");
function ReadableStreamReaderGenericInitialize(reader, stream) {
reader._ownerReadableStream = stream;
stream._reader = reader;
if (stream._state === "readable") {
defaultReaderClosedPromiseInitialize(reader);
} else if (stream._state === "closed") {
defaultReaderClosedPromiseInitializeAsResolved(reader);
} else {
defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
}
}
function ReadableStreamReaderGenericCancel(reader, reason) {
const stream = reader._ownerReadableStream;
return ReadableStreamCancel(stream, reason);
}
function ReadableStreamReaderGenericRelease(reader) {
const stream = reader._ownerReadableStream;
if (stream._state === "readable") {
defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
} else {
defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
}
stream._readableStreamController[ReleaseSteps]();
stream._reader = void 0;
reader._ownerReadableStream = void 0;
}
function readerLockException(name) {
return new TypeError("Cannot " + name + " a stream using a released reader");
}
function defaultReaderClosedPromiseInitialize(reader) {
reader._closedPromise = newPromise((resolve, reject) => {
reader._closedPromise_resolve = resolve;
reader._closedPromise_reject = reject;
});
}
function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
defaultReaderClosedPromiseInitialize(reader);
defaultReaderClosedPromiseReject(reader, reason);
}
function defaultReaderClosedPromiseInitializeAsResolved(reader) {
defaultReaderClosedPromiseInitialize(reader);
defaultReaderClosedPromiseResolve(reader);
}
function defaultReaderClosedPromiseReject(reader, reason) {
if (reader._closedPromise_reject === void 0) {
return;
}
setPromiseIsHandledToTrue(reader._closedPromise);
reader._closedPromise_reject(reason);
reader._closedPromise_resolve = void 0;
reader._closedPromise_reject = void 0;
}
function defaultReaderClosedPromiseResetToRejected(reader, reason) {
defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
}
function defaultReaderClosedPromiseResolve(reader) {
if (reader._closedPromise_resolve === void 0) {
return;
}
reader._closedPromise_resolve(void 0);
reader._closedPromise_resolve = void 0;
reader._closedPromise_reject = void 0;
}
const NumberIsFinite = Number.isFinite || function(x2) {
return typeof x2 === "number" && isFinite(x2);
};
const MathTrunc = Math.trunc || function(v) {
return v < 0 ? Math.ceil(v) : Math.floor(v);
};
function isDictionary(x2) {
return typeof x2 === "object" || typeof x2 === "function";
}
function assertDictionary(obj, context) {
if (obj !== void 0 && !isDictionary(obj)) {
throw new TypeError(`${context} is not an object.`);
}
}
function assertFunction(x2, context) {
if (typeof x2 !== "function") {
throw new TypeError(`${context} is not a function.`);
}
}
function isObject(x2) {
return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
}
function assertObject(x2, context) {
if (!isObject(x2)) {
throw new TypeError(`${context} is not an object.`);
}
}
function assertRequiredArgument(x2, position, context) {
if (x2 === void 0) {
throw new TypeError(`Parameter ${position} is required in '${context}'.`);
}
}
function assertRequiredField(x2, field, context) {
if (x2 === void 0) {
throw new TypeError(`${field} is required in '${context}'.`);
}
}
function convertUnrestrictedDouble(value) {
return Number(value);
}
function censorNegativeZero(x2) {
return x2 === 0 ? 0 : x2;
}
function integerPart(x2) {
return censorNegativeZero(MathTrunc(x2));
}
function convertUnsignedLongLongWithEnforceRange(value, context) {
const lowerBound = 0;
const upperBound = Number.MAX_SAFE_INTEGER;
let x2 = Number(value);
x2 = censorNegativeZero(x2);
if (!NumberIsFinite(x2)) {
throw new TypeError(`${context} is not a finite number`);
}
x2 = integerPart(x2);
if (x2 < lowerBound || x2 > upperBound) {
throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);
}
if (!NumberIsFinite(x2) || x2 === 0) {
return 0;
}
return x2;
}
function assertReadableStream(x2, context) {
if (!IsReadableStream(x2)) {
throw new TypeError(`${context} is not a ReadableStream.`);
}
}
function AcquireReadableStreamDefaultReader(stream) {
return new ReadableStreamDefaultReader(stream);
}
function ReadableStreamAddReadRequest(stream, readRequest) {
stream._reader._readRequests.push(readRequest);
}
function ReadableStreamFulfillReadRequest(stream, chunk, done) {
const reader = stream._reader;
const readRequest = reader._readRequests.shift();
if (done) {
readRequest._closeSteps();
} else {
readRequest._chunkSteps(chunk);
}
}
function ReadableStreamGetNumReadRequests(stream) {
return stream._reader._readRequests.length;
}
function ReadableStreamHasDefaultReader(stream) {
const reader = stream._reader;
if (reader === void 0) {
return false;
}
if (!IsReadableStreamDefaultReader(reader)) {
return false;
}
return true;
}
class ReadableStreamDefaultReader {
constructor(stream) {
assertRequiredArgument(stream, 1, "ReadableStreamDefaultReader");
assertReadableStream(stream, "First parameter");
if (IsReadableStreamLocked(stream)) {
throw new TypeError("This stream has already been locked for exclusive reading by another reader");
}
ReadableStreamReaderGenericInitialize(this, stream);
this._readRequests = new SimpleQueue();
}
/**
* Returns a promise that will be fulfilled when the stream becomes closed,
* or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
*/
get closed() {
if (!IsReadableStreamDefaultReader(this)) {
return promiseRejectedWith(defaultReaderBrandCheckException("closed"));
}
return this._closedPromise;
}
/**
* If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
*/
cancel(reason = void 0) {
if (!IsReadableStreamDefaultReader(this)) {
return promiseRejectedWith(defaultReaderBrandCheckException("cancel"));
}
if (this._ownerReadableStream === void 0) {
return promiseRejectedWith(readerLockException("cancel"));
}
return ReadableStreamReaderGenericCancel(this, reason);
}
/**
* Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
*
* If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
*/
read() {
if (!IsReadableStreamDefaultReader(this)) {
return promiseRejectedWith(defaultReaderBrandCheckException("read"));
}
if (this._ownerReadableStream === void 0) {
return promiseRejectedWith(readerLockException("read from"));
}
let resolvePromise;
let rejectPromise;
const promise = newPromise((resolve, reject) => {
resolvePromise = resolve;
rejectPromise = reject;
});
const readRequest = {
_chunkSteps: (chunk) => resolvePromise({ value: chunk, done: false }),
_closeSteps: () => resolvePromise({ value: void 0, done: true }),
_errorSteps: (e2) => rejectPromise(e2)
};
ReadableStreamDefaultReaderRead(this, readRequest);
return promise;
}
/**
* Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
* If the associated stream is errored when the lock is released, the reader will appear errored in the same way
* from now on; otherwise, the reader will appear closed.
*
* A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
* the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
* do so will throw a `TypeError` and leave the reader locked to the stream.
*/
releaseLock() {
if (!IsReadableStreamDefaultReader(this)) {
throw defaultReaderBrandCheckException("releaseLock");
}
if (this._ownerReadableStream === void 0) {
return;
}
ReadableStreamDefaultReaderRelease(this);
}
}
Object.defineProperties(ReadableStreamDefaultReader.prototype, {
cancel: { enumerable: true },
read: { enumerable: true },
releaseLock: { enumerable: true },
closed: { enumerable: true }
});
setFunctionName(ReadableStreamDefaultReader.prototype.cancel, "cancel");
setFunctionName(ReadableStreamDefaultReader.prototype.read, "read");
setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock");
if (typeof Symbol.toStringTag === "symbol") {
Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
value: "ReadableStreamDefaultReader",
configurable: true
});
}
function IsReadableStreamDefaultReader(x2) {
if (!typeIsObject(x2)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x2, "_readRequests")) {
return false;
}
return x2 instanceof ReadableStreamDefaultReader;
}
function ReadableStreamDefaultReaderRead(reader, readRequest) {
const stream = reader._ownerReadableStream;
stream._disturbed = true;
if (stream._state === "closed") {
readRequest._closeSteps();
} else if (stream._state === "errored") {
readRequest._errorSteps(stream._storedError);
} else {
stream._readableStreamController[PullSteps](readRequest);
}
}
function ReadableStreamDefaultReaderRelease(reader) {
ReadableStreamReaderGenericRelease(reader);
const e2 = new TypeError("Reader was released");
ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
}
function ReadableStreamDefaultReaderErrorReadRequests(reader, e2) {
const readRequests = reader._readRequests;
reader._readRequests = new SimpleQueue();
readRequests.forEach((readRequest) => {
readRequest._errorSteps(e2);
});
}
function defaultReaderBrandCheckException(name) {
return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
}
const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
}).prototype);
class ReadableStreamAsyncIteratorImpl {
constructor(reader, preventCancel) {
this._ongoingPromise = void 0;
this._isFinished = false;
this._reader = reader;
this._preventCancel = preventCancel;
}
next() {
const nextSteps = () => this._nextSteps();
this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps();
return this._ongoingPromise;
}
return(value) {
const returnSteps = () => this._returnSteps(value);
return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps();
}
_nextSteps() {
if (this._isFinished) {
return Promise.resolve({ value: void 0, done: true });
}
const reader = this._reader;
let resolvePromise;
let rejectPromise;
const promise = newPromise((resolve, reject) => {
resolvePromise = resolve;
rejectPromise = reject;
});
const readRequest = {
_chunkSteps: (chunk) => {
this._ongoingPromise = void 0;
_queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
},
_closeSteps: () => {
this._ongoingPromise = void 0;
this._isFinished = true;
ReadableStreamReaderGenericRelease(reader);
resolvePromise({ value: void 0, done: true });
},
_errorSteps: (reason) => {
this._ongoingPromise = void 0;
this._isFinished = true;
ReadableStreamReaderGenericRelease(reader);
rejectPromise(reason);
}
};
ReadableStreamDefaultReaderRead(reader, readRequest);
return promise;
}
_returnSteps(value) {
if (this._isFinished) {
return Promise.resolve({ value, done: true });
}
this._isFinished = true;
const reader = this._reader;
if (!this._preventCancel) {
const result = ReadableStreamReaderGenericCancel(reader, value);
ReadableStreamReaderGenericRelease(reader);
return transformPromiseWith(result, () => ({ value, done: true }));
}
ReadableStreamReaderGenericRelease(reader);
return promiseResolvedWith({ value, done: true });
}
}
const ReadableStreamAsyncIteratorPrototype = {
next() {
if (!IsReadableStreamAsyncIterator(this)) {
return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
}
return this._asyncIteratorImpl.next();
},
return(value) {
if (!IsReadableStreamAsyncIterator(this)) {
return promiseRejectedWith(streamAsyncIteratorBrandCheckException("return"));
}
return this._asyncIteratorImpl.return(value);
}
};
Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
const reader = AcquireReadableStreamDefaultReader(stream);
const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
iterator._asyncIteratorImpl = impl;
return iterator;
}
function IsReadableStreamAsyncIterator(x2) {
if (!typeIsObject(x2)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x2, "_asyncIteratorImpl")) {
return false;
}
try {
return x2._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
} catch (_a2) {
return false;
}
}
function streamAsyncIteratorBrandCheckException(name) {
return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
}
const NumberIsNaN = Number.isNaN || function(x2) {
return x2 !== x2;
};
var _a, _b, _c;
function CreateArrayFromList(elements) {
return elements.slice();
}
function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
}
let TransferArrayBuffer = (O) => {
if (typeof O.transfer === "function") {
TransferArrayBuffer = (buffer) => buffer.transfer();
} else if (typeof structuredClone === "function") {
TransferArrayBuffer = (buffer) => structuredClone(buffer, { transfer: [buffer] });
} else {
TransferArrayBuffer = (buffer) => buffer;
}
return TransferArrayBuffer(O);
};
let IsDetachedBuffer = (O) => {
if (typeof O.detached === "boolean") {
IsDetachedBuffer = (buffer) => buffer.detached;
} else {
IsDetachedBuffer = (buffer) => buffer.byteLength === 0;
}
return IsDetachedBuffer(O);
};
function ArrayBufferSlice(buffer, begin, end) {
if (buffer.slice) {
return buffer.slice(begin, end);
}
const length = end - begin;
const slice = new ArrayBuffer(length);
CopyDataBlockBytes(slice, 0, buffer, begin, length);
return slice;
}
function GetMethod(receiver, prop) {
const func = receiver[prop];
if (func === void 0 || func === null) {
return void 0;
}
if (typeof func !== "function") {
throw new TypeError(`${String(prop)} is not a function`);
}
return func;
}
function CreateAsyncFromSyncIterator(syncIteratorRecord) {
const syncIterable = {
[Symbol.iterator]: () => syncIteratorRecord.iterator
};
const asyncIterator = async function* () {
return yield* syncIterable;
}();
const nextMethod = asyncIterator.next;
return { iterator: asyncIterator, nextMethod, done: false };
}
const SymbolAsyncIterator = (_c = (_a = Symbol.asyncIterator) !== null && _a !== void 0 ? _a : (_b = Symbol.for) === null || _b === void 0 ? void 0 : _b.call(Symbol, "Symbol.asyncIterator")) !== null && _c !== void 0 ? _c : "@@asyncIterator";
function GetIterator(obj, hint = "sync", method) {
if (method === void 0) {
if (hint === "async") {
method = GetMethod(obj, SymbolAsyncIterator);
if (method === void 0) {
const syncMethod = GetMethod(obj, Symbol.iterator);
const syncIteratorRecord = GetIterator(obj, "sync", syncMethod);
return CreateAsyncFromSyncIterator(syncIteratorRecord);
}
} else {
method = GetMethod(obj, Symbol.iterator);
}
}
if (method === void 0) {
throw new TypeError("The object is not iterable");
}
const iterator = reflectCall(method, obj, []);
if (!typeIsObject(iterator)) {
throw new TypeError("The iterator method must return an object");
}
const nextMethod = iterator.next;
return { iterator, nextMethod, done: false };
}
function IteratorNext(iteratorRecord) {
const result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);
if (!typeIsObject(result)) {
throw new TypeError("The iterator.next() method must return an object");
}
return result;
}
function IteratorComplete(iterResult) {
return Boolean(iterResult.done);
}
function IteratorValue(iterResult) {
return iterResult.value;
}
function IsNonNegativeNumber(v) {
if (typeof v !== "number") {
return false;
}
if (NumberIsNaN(v)) {
return false;
}
if (v < 0) {
return false;
}
return true;
}
function CloneAsUint8Array(O) {
const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
return new Uint8Array(buffer);
}
function DequeueValue(container) {
const pair = container._queue.shift();
container._queueTotalSize -= pair.size;
if (container._queueTotalSize < 0) {
container._queueTotalSize = 0;
}
return pair.value;
}
function EnqueueValueWithSize(container, value, size) {
if (!IsNonNegativeNumber(size) || size === Infinity) {
throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
}
container._queue.push({ value, size });
container._queueTotalSize += size;
}
function PeekQueueValue(container) {
const pair = container._queue.peek();
return pair.value;
}
function ResetQueue(container) {
container._queue = new SimpleQueue();
container._queueTotalSize = 0;
}
function isDataViewConstructor(ctor) {
return ctor === DataView;
}
function isDataView(view) {
return isDataViewConstructor(view.constructor);
}
function arrayBufferViewElementSize(ctor) {
if (isDataViewConstructor(ctor)) {
return 1;
}
return ctor.BYTES_PER_ELEMENT;
}
class ReadableStreamBYOBRequest {
constructor() {
throw new TypeError("Illegal constructor");
}
/**
* Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
*/
get view() {
if (!IsReadableStreamBYOBRequest(this)) {
throw byobRequestBrandCheckException("view");
}
return this._view;
}
respond(bytesWritten) {
if (!IsReadableStreamBYOBRequest(this)) {
throw byobRequestBrandCheckException("respond");
}
assertRequiredArgument(bytesWritten, 1, "respond");
bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, "First parameter");
if (this._associatedReadableByteStreamController === void 0) {
throw new TypeError("This BYOB request has been invalidated");
}
if (IsDetachedBuffer(this._view.buffer)) {
throw new TypeError(`The BYOB request's buffer has been detached and so cannot be used as a response`);
}
ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
}
respondWithNewView(view) {
if (!IsReadableStreamBYOBRequest(this)) {
throw byobRequestBrandCheckException("respondWithNewView");
}
assertRequiredArgument(view, 1, "respondWithNewView");
if (!ArrayBuffer.isView(view)) {
throw new TypeError("You can only respond with array buffer views");
}
if (this._associatedReadableByteStreamController === void 0) {
throw new TypeError("This BYOB request has been invalidated");
}
if (IsDetachedBuffer(view.buffer)) {
throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
}
ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
}
}
Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
respond: { enumerable: true },
respondWithNewView: { enumerable: true },
view: { enumerable: true }
});
setFunctionName(ReadableStreamBYOBRequest.prototype.respond, "respond");
setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView");
if (typeof Symbol.toStringTag === "symbol") {
Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {
value: "ReadableStreamBYOBRequest",
configurable: true
});
}
class ReadableByteStreamController {
constructor() {
throw new TypeError("Illegal constructor");
}
/**
* Returns the current BYOB pull request, or `null` if there isn't one.
*/
get byobRequest() {
if (!IsReadableByteStreamController(this)) {
throw byteStreamControllerBrandCheckException("byobRequest");
}
return ReadableByteStreamControllerGetBYOBRequest(this);
}
/**
* Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
* over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
*/
get desiredSize() {
if (!IsReadableByteStreamController(this)) {
throw byteStreamControllerBrandCheckException("desiredSize");
}
return ReadableByteStreamControllerGetDesiredSize(this);
}
/**
* Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
* the stream, but once those are read, the stream will become closed.
*/
close() {
if (!IsReadableByteStreamController(this)) {
throw byteStreamControllerBrandCheckException("close");
}
if (this._closeRequested) {
throw new TypeError("The stream has already been closed; do not close it again!");
}
const state = this._controlledReadableByteStream._state;
if (state !== "readable") {
throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);
}
ReadableByteStreamControllerClose(this);
}
enqueue(chunk) {
if (!IsReadableByteStreamController(this)) {
throw byteStreamControllerBrandCheckException("enqueue");
}
assertRequiredArgument(chunk, 1, "enqueue");
if (!ArrayBuffer.isView(chunk)) {
throw new TypeError("chunk must be an array buffer view");
}
if (chunk.byteLength === 0) {
throw new TypeError("chunk must have non-zero byteLength");
}
if (chunk.buffer.byteLength === 0) {
throw new TypeError(`chunk's buffer must have non-zero byteLength`);
}
if (this._closeRequested) {
throw new TypeError("stream is closed or draining");
}
const state = this._controlledReadableByteStream._state;
if (state !== "readable") {
throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);
}
ReadableByteStreamControllerEnqueue(this, chunk);
}
/**
* Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
*/
error(e2 = void 0) {
if (!IsReadableByteStreamController(this)) {
throw byteStreamControllerBrandCheckException("error");
}
ReadableByteStreamControllerError(this, e2);
}
/** @internal */
[CancelSteps](reason) {
ReadableByteStreamControllerClearPendingPullIntos(this);
ResetQueue(this);
const result = this._cancelAlgorithm(reason);
ReadableByteStreamControllerClearAlgorithms(this);
return result;
}
/** @internal */
[PullSteps](readRequest) {
const stream = this._controlledReadableByteStream;
if (this._queueTotalSize > 0) {
ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);
return;
}
const autoAllocateChunkSize = this._autoAllocateChunkSize;
if (autoAllocateChunkSize !== void 0) {
let buffer;
try {
buffer = new ArrayBuffer(autoAllocateChunkSize);
} catch (bufferE) {
readRequest._errorSteps(bufferE);
return;
}
const pullIntoDescriptor = {
buffer,
bufferByteLength: autoAllocateChunkSize,
byteOffset: 0,
byteLength: autoAllocateChunkSize,
bytesFilled: 0,
minimumFill: 1,
elementSize: 1,
viewConstructor: Uint8Array,
readerType: "default"
};
this._pendingPullIntos.push(pullIntoDescriptor);
}
ReadableStreamAddReadRequest(stream, readRequest);
ReadableByteStreamControllerCallPullIfNeeded(this);
}
/** @internal */
[ReleaseSteps]() {
if (this._pendingPullIntos.length > 0) {
const firstPullInto = this._pendingPullIntos.peek();
firstPullInto.readerType = "none";
this._pendingPullIntos = new SimpleQueue();
this._pendingPullIntos.push(firstPullInto);
}
}
}
Object.defineProperties(ReadableByteStreamController.prototype, {
close: { enumerable: true },
enqueue: { enumerable: true },
error: { enumerable: true },
byobRequest: { enumerable: true },
desiredSize: { enumerable: true }
});
setFunctionName(ReadableByteStreamController.prototype.close, "close");
setFunctionName(ReadableByteStreamController.prototype.enqueue, "enqueue");
setFunctionName(ReadableByteStreamController.prototype.error, "error");
if (typeof Symbol.toStringTag === "symbol") {
Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {
value: "ReadableByteStreamController",
configurable: true
});
}
function IsReadableByteStreamController(x2) {
if (!typeIsObject(x2)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x2, "_controlledReadableByteStream")) {
return false;
}
return x2 instanceof ReadableByteStreamController;
}
function IsReadableStreamBYOBRequest(x2) {
if (!typeIsObject(x2)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x2, "_associatedReadableByteStreamController")) {
return false;
}
return x2 instanceof ReadableStreamBYOBRequest;
}
function ReadableByteStreamControllerCallPullIfNeeded(controller) {
const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
if (!shouldPull) {
return;
}
if (controller._pulling) {
controller._pullAgain = true;
return;
}
controller._pulling = true;
const pullPromise = controller._pullAlgorithm();
uponPromise(pullPromise, () => {
controller._pulling = false;
if (controller._pullAgain) {
controller._pullAgain = false;
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
return null;
}, (e2) => {
ReadableByteStreamControllerError(controller, e2);
return null;
});
}
function ReadableByteStreamControllerClearPendingPullIntos(controller) {
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
controller._pendingPullIntos = new SimpleQueue();
}
function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
let done = false;
if (stream._state === "closed") {
done = true;
}
const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
if (pullIntoDescriptor.readerType === "default") {
ReadableStreamFulfillReadRequest(stream, filledView, done);
} else {
ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
}
}
function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
const bytesFilled = pullIntoDescriptor.bytesFilled;
const elementSize = pullIntoDescriptor.elementSize;
return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
}
function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
controller._queue.push({ buffer, byteOffset, byteLength });
controller._queueTotalSize += byteLength;
}
function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer, byteOffset, byteLength) {
let clonedChunk;
try {
clonedChunk = ArrayBufferSlice(buffer, byteOffset, byteOffset + byteLength);
} catch (cloneE) {
ReadableByteStreamControllerError(controller, cloneE);
throw cloneE;
}
ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
}
function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstDescriptor) {
if (firstDescriptor.bytesFilled > 0) {
ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, firstDescriptor.buffer, firstDescriptor.byteOffset, firstDescriptor.bytesFilled);
}
ReadableByteStreamControllerShiftPendingPullInto(controller);
}
function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
let totalBytesToCopyRemaining = maxBytesToCopy;
let ready = false;
const remainderBytes = maxBytesFilled % pullIntoDescriptor.elementSize;
const maxAlignedBytes = maxBytesFilled - remainderBytes;
if (maxAlignedBytes >= pullIntoDescriptor.minimumFill) {
totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
ready = true;
}
const queue = controller._queue;
while (totalBytesToCopyRemaining > 0) {
const headOfQueue = queue.peek();
const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
if (headOfQueue.byteLength === bytesToCopy) {
queue.shift();
} else {
headOfQueue.byteOffset += bytesToCopy;
headOfQueue.byteLength -= bytesToCopy;
}
controller._queueTotalSize -= bytesToCopy;
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
totalBytesToCopyRemaining -= bytesToCopy;
}
return ready;
}
function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
pullIntoDescriptor.bytesFilled += size;
}
function ReadableByteStreamControllerHandleQueueDrain(controller) {
if (controller._queueTotalSize === 0 && controller._closeRequested) {
ReadableByteStreamControllerClearAlgorithms(controller);
ReadableStreamClose(controller._controlledReadableByteStream);
} else {
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
}
function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
if (controller._byobRequest === null) {
return;
}
controller._byobRequest._associatedReadableByteStreamController = void 0;
controller._byobRequest._view = null;
controller._byobRequest = null;
}
function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
while (controller._pendingPullIntos.length > 0) {
if (controller._queueTotalSize === 0) {
return;
}
const pullIntoDescriptor = controller._pendingPullIntos.peek();
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
ReadableByteStreamControllerShiftPendingPullInto(controller);
ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
}
}
}
function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
const reader = controller._controlledReadableByteStream._reader;
while (reader._readRequests.length > 0) {
if (controller._queueTotalSize === 0) {
return;
}
const readRequest = reader._readRequests.shift();
ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest);
}
}
function ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest) {
const stream = controller._controlledReadableByteStream;
const ctor = view.constructor;
const elementSize = arrayBufferViewElementSize(ctor);
const { byteOffset, byteLength } = view;
const minimumFill = min * elementSize;
let buffer;
try {
buffer = TransferArrayBuffer(view.buffer);
} catch (e2) {
readIntoRequest._errorSteps(e2);
return;
}
const pullIntoDescriptor = {
buffer,
bufferByteLength: buffer.byteLength,
byteOffset,
byteLength,
bytesFilled: 0,
minimumFill,
elementSize,
viewConstructor: ctor,
readerType: "byob"
};
if (controller._pendingPullIntos.length > 0) {
controller._pendingPullIntos.push(pullIntoDescriptor);
ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
return;
}
if (stream._state === "closed") {
const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
readIntoRequest._closeSteps(emptyView);
return;
}
if (controller._queueTotalSize > 0) {
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
ReadableByteStreamControllerHandleQueueDrain(controller);
readIntoRequest._chunkSteps(filledView);
return;
}
if (controller._closeRequested) {
const e2 = new TypeError("Insufficient bytes to fill elements in the given buffer");
ReadableByteStreamControllerError(controller, e2);
readIntoRequest._errorSteps(e2);
return;
}
}
controller._pendingPullIntos.push(pullIntoDescriptor);
ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
if (firstDescriptor.readerType === "none") {
ReadableByteStreamControllerShiftPendingPullInto(controller);
}
const stream = controller._controlledReadableByteStream;
if (ReadableStreamHasBYOBReader(stream)) {
while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
}
}
}
function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pu