@dcl/sdk 7.24.5 → 7.24.6-29580060460.commit-06f0b7e

package/composite-provider.js

@@ -1,6 +1,7 @@
 import { compositeFromLoader } from '~sdk/all-composites';
 import { readFile } from '~system/Runtime';
-import { Composite, getGlobal } from '@dcl/ecs';
+import { Composite } from '@dcl/ecs';
+import { decodeUtf8 } from './internal/utf8';
 const composites = new Map();
 function findCached(src) {
     return composites.get(src) ?? null;
@@ -27,14 +28,8 @@ function decodeFromBytes(content) {
     // The first-byte check is a fast path; a JSON.parse failure falls back to fromBinary
     // because a protobuf message can also begin with 0x7b.
     if (content[0] === 0x7b /* '{' */) {
-        const TD = getGlobal('TextDecoder');
-        if (!TD) {
-            throw new Error('loadComposite: TextDecoder is not available in this runtime. ' +
-                'Use a .composite.bin file, or import `@dcl/sdk/ethereum-provider` ' +
-                'to install the TextEncoder/TextDecoder polyfill.');
-        }
         try {
-            return Composite.fromJson(JSON.parse(new TD().decode(content)));
+            return Composite.fromJson(JSON.parse(decodeUtf8(content, { fatal: true })));
         }
         catch {
             return Composite.fromBinary(content);
@@ -69,4 +64,4 @@ export const compositeProvider = {
         return cache(src, composite);
     }
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9zaXRlLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic3JjL2NvbXBvc2l0ZS1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQTtBQUN6RCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDMUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsTUFBTSxVQUFVLENBQUE7QUFFL0MsTUFBTSxVQUFVLEdBQUcsSUFBSSxHQUFHLEVBQThCLENBQUE7QUFFeEQsU0FBUyxVQUFVLENBQUMsR0FBVztJQUM3QixPQUFPLFVBQVUsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLElBQUksSUFBSSxDQUFBO0FBQ3BDLENBQUM7QUFFRCxTQUFTLEtBQUssQ0FBQyxHQUFXLEVBQUUsU0FBK0I7SUFDekQsTUFBTSxRQUFRLEdBQUcsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQ2hDLElBQUksUUFBUTtRQUFFLE9BQU8sUUFBUSxDQUFBO0lBQzdCLE1BQU0sUUFBUSxHQUF1QixFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsQ0FBQTtJQUN2RCxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxRQUFRLENBQUMsQ0FBQTtJQUM3QixPQUFPLFFBQVEsQ0FBQTtBQUNqQixDQUFDO0FBRUQsU0FBUyxnQkFBZ0IsQ0FBQyxHQUFXLEVBQUUsVUFBbUI7SUFDeEQsSUFBSSxVQUFVLFlBQVksVUFBVTtRQUFFLE9BQU8sU0FBUyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FBQTtJQUM3RSxJQUFJLE9BQU8sVUFBVSxLQUFLLFFBQVE7UUFBRSxPQUFPLFNBQVMsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFBO0lBQ3JGLElBQUksT0FBTyxVQUFVLEtBQUssUUFBUSxJQUFJLFVBQVUsS0FBSyxJQUFJO1FBQUUsT0FBTyxTQUFTLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBQ2hHLE9BQU8sSUFBSSxDQUFBO0FBQ2IsQ0FBQztBQUVELFNBQVMsZUFBZSxDQUFDLE9BQW1CO0lBQzFDLCtFQUErRTtJQUMvRSxxRkFBcUY7SUFDckYsdURBQXVEO0lBQ3ZELElBQUksT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUFLLElBQUksQ0FBQyxTQUFTLEVBQUU7UUFDakMsTUFBTSxFQUFFLEdBQUcsU0FBUyxDQUFrRCxhQUFhLENBQUMsQ0FBQTtRQUNwRixJQUFJLENBQUMsRUFBRSxFQUFFO1lBQ1AsTUFBTSxJQUFJLEtBQUssQ0FDYiwrREFBK0Q7Z0JBQzdELG9FQUFvRTtnQkFDcEUsa0RBQWtELENBQ3JELENBQUE7U0FDRjtRQUNELElBQUk7WUFDRixPQUFPLFNBQVMsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUE7U0FDaEU7UUFBQyxNQUFNO1lBQ04sT0FBTyxTQUFTLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxDQUFBO1NBQ3JDO0tBQ0Y7SUFDRCxPQUFPLFNBQVMsQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUE7QUFDdEMsQ0FBQztBQUVELFVBQVU7QUFDVixNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBdUI7SUFDbkQsT0FBTyxFQUFFLEVBQUU7SUFDWCxrQkFBa0IsQ0FBQyxHQUFXO1FBQzVCLE1BQU0sVUFBVSxHQUFHLG1CQUFtQixDQUFDLEdBQUcsQ0FBQyxDQUFBO1FBQzNDLElBQUksVUFBVSxFQUFFO1lBQ2QsSUFBSTtnQkFDRixNQUFNLFNBQVMsR0FBRyxnQkFBZ0IsQ0FBQyxHQUFHLEVBQUUsVUFBVSxDQUFDLENBQUE7Z0JBQ25ELElBQUksU0FBUztvQkFBRSxLQUFLLENBQUMsR0FBRyxFQUFFLFNBQVMsQ0FBQyxDQUFBO2FBQ3JDO1lBQUMsT0FBTyxHQUFHLEVBQUU7Z0JBQ1osT0FBTyxDQUFDLEtBQUssQ0FBQyxrREFBa0QsR0FBRyxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUE7YUFDN0U7WUFDRCxPQUFPLG1CQUFtQixDQUFDLEdBQUcsQ0FBQyxDQUFBO1NBQ2hDO1FBRUQsT0FBTyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUE7SUFDeEIsQ0FBQztJQUVELEtBQUssQ0FBQyxhQUFhLENBQUMsR0FBVztRQUM3QixNQUFNLE1BQU0sR0FBRyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDOUIsSUFBSSxNQUFNO1lBQUUsT0FBTyxNQUFNLENBQUE7UUFFekIsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLE1BQU0sUUFBUSxDQUFDLEVBQUUsUUFBUSxFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUE7UUFDckQsTUFBTSxTQUFTLEdBQUcsZUFBZSxDQUFDLE9BQU8sQ0FBQyxDQUFBO1FBQzFDLE9BQU8sS0FBSyxDQUFDLEdBQUcsRUFBRSxTQUFTLENBQUMsQ0FBQTtJQUM5QixDQUFDO0NBQ0YsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNvbXBvc2l0ZUZyb21Mb2FkZXIgfSBmcm9tICd+c2RrL2FsbC1jb21wb3NpdGVzJ1xuaW1wb3J0IHsgcmVhZEZpbGUgfSBmcm9tICd+c3lzdGVtL1J1bnRpbWUnXG5pbXBvcnQgeyBDb21wb3NpdGUsIGdldEdsb2JhbCB9IGZyb20gJ0BkY2wvZWNzJ1xuXG5jb25zdCBjb21wb3NpdGVzID0gbmV3IE1hcDxzdHJpbmcsIENvbXBvc2l0ZS5SZXNvdXJjZT4oKVxuXG5mdW5jdGlvbiBmaW5kQ2FjaGVkKHNyYzogc3RyaW5nKTogQ29tcG9zaXRlLlJlc291cmNlIHwgbnVsbCB7XG4gIHJldHVybiBjb21wb3NpdGVzLmdldChzcmMpID8/IG51bGxcbn1cblxuZnVuY3Rpb24gY2FjaGUoc3JjOiBzdHJpbmcsIGNvbXBvc2l0ZTogQ29tcG9zaXRlLkRlZmluaXRpb24pOiBDb21wb3NpdGUuUmVzb3VyY2Uge1xuICBjb25zdCBleGlzdGluZyA9IGZpbmRDYWNoZWQoc3JjKVxuICBpZiAoZXhpc3RpbmcpIHJldHVybiBleGlzdGluZ1xuICBjb25zdCByZXNvdXJjZTogQ29tcG9zaXRlLlJlc291cmNlID0geyBzcmMsIGNvbXBvc2l0ZSB9XG4gIGNvbXBvc2l0ZXMuc2V0KHNyYywgcmVzb3VyY2UpXG4gIHJldHVybiByZXNvdXJjZVxufVxuXG5mdW5jdGlvbiBkZWNvZGVGcm9tTG9hZGVyKHNyYzogc3RyaW5nLCBmcm9tTG9hZGVyOiB1bmtub3duKTogQ29tcG9zaXRlLkRlZmluaXRpb24gfCBudWxsIHtcbiAgaWYgKGZyb21Mb2FkZXIgaW5zdGFuY2VvZiBVaW50OEFycmF5KSByZXR1cm4gQ29tcG9zaXRlLmZyb21CaW5hcnkoZnJvbUxvYWRlcilcbiAgaWYgKHR5cGVvZiBmcm9tTG9hZGVyID09PSAnc3RyaW5nJykgcmV0dXJuIENvbXBvc2l0ZS5mcm9tSnNvbihKU09OLnBhcnNlKGZyb21Mb2FkZXIpKVxuICBpZiAodHlwZW9mIGZyb21Mb2FkZXIgPT09ICdvYmplY3QnICYmIGZyb21Mb2FkZXIgIT09IG51bGwpIHJldHVybiBDb21wb3NpdGUuZnJvbUpzb24oZnJvbUxvYWRlcilcbiAgcmV0dXJuIG51bGxcbn1cblxuZnVuY3Rpb24gZGVjb2RlRnJvbUJ5dGVzKGNvbnRlbnQ6IFVpbnQ4QXJyYXkpOiBDb21wb3NpdGUuRGVmaW5pdGlvbiB7XG4gIC8vIC5jb21wb3NpdGUgZmlsZXMgYXJlIEpTT04gKFVURi04KTsgLmNvbXBvc2l0ZS5iaW4gZmlsZXMgYXJlIHByb3RvYnVmIGJpbmFyeS5cbiAgLy8gVGhlIGZpcnN0LWJ5dGUgY2hlY2sgaXMgYSBmYXN0IHBhdGg7IGEgSlNPTi5wYXJzZSBmYWlsdXJlIGZhbGxzIGJhY2sgdG8gZnJvbUJpbmFyeVxuICAvLyBiZWNhdXNlIGEgcHJvdG9idWYgbWVzc2FnZSBjYW4gYWxzbyBiZWdpbiB3aXRoIDB4N2IuXG4gIGlmIChjb250ZW50WzBdID09PSAweDdiIC8qICd7JyAqLykge1xuICAgIGNvbnN0IFREID0gZ2V0R2xvYmFsPG5ldyAoKSA9PiB7IGRlY29kZShpbnB1dDogVWludDhBcnJheSk6IHN0cmluZyB9PignVGV4dERlY29kZXInKVxuICAgIGlmICghVEQpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICAgJ2xvYWRDb21wb3NpdGU6IFRleHREZWNvZGVyIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhpcyBydW50aW1lLiAnICtcbiAgICAgICAgICAnVXNlIGEgLmNvbXBvc2l0ZS5iaW4gZmlsZSwgb3IgaW1wb3J0IGBAZGNsL3Nkay9ldGhlcmV1bS1wcm92aWRlcmAgJyArXG4gICAgICAgICAgJ3RvIGluc3RhbGwgdGhlIFRleHRFbmNvZGVyL1RleHREZWNvZGVyIHBvbHlmaWxsLidcbiAgICAgIClcbiAgICB9XG4gICAgdHJ5IHtcbiAgICAgIHJldHVybiBDb21wb3NpdGUuZnJvbUpzb24oSlNPTi5wYXJzZShuZXcgVEQoKS5kZWNvZGUoY29udGVudCkpKVxuICAgIH0gY2F0Y2gge1xuICAgICAgcmV0dXJuIENvbXBvc2l0ZS5mcm9tQmluYXJ5KGNvbnRlbnQpXG4gICAgfVxuICB9XG4gIHJldHVybiBDb21wb3NpdGUuZnJvbUJpbmFyeShjb250ZW50KVxufVxuXG4vLyBAcHVibGljXG5leHBvcnQgY29uc3QgY29tcG9zaXRlUHJvdmlkZXI6IENvbXBvc2l0ZS5Qcm92aWRlciA9IHtcbiAgc2NoZW1hczogW10sXG4gIGdldENvbXBvc2l0ZU9yTnVsbChzcmM6IHN0cmluZykge1xuICAgIGNvbnN0IGZyb21Mb2FkZXIgPSBjb21wb3NpdGVGcm9tTG9hZGVyW3NyY11cbiAgICBpZiAoZnJvbUxvYWRlcikge1xuICAgICAgdHJ5IHtcbiAgICAgICAgY29uc3QgY29tcG9zaXRlID0gZGVjb2RlRnJvbUxvYWRlcihzcmMsIGZyb21Mb2FkZXIpXG4gICAgICAgIGlmIChjb21wb3NpdGUpIGNhY2hlKHNyYywgY29tcG9zaXRlKVxuICAgICAgfSBjYXRjaCAoZXJyKSB7XG4gICAgICAgIGNvbnNvbGUuZXJyb3IoYGNvbXBvc2l0ZVByb3ZpZGVyOiBmYWlsZWQgdG8gZGVjb2RlIGNvbXBvc2l0ZSBcIiR7c3JjfVwiYCwgZXJyKVxuICAgICAgfVxuICAgICAgZGVsZXRlIGNvbXBvc2l0ZUZyb21Mb2FkZXJbc3JjXVxuICAgIH1cblxuICAgIHJldHVybiBmaW5kQ2FjaGVkKHNyYylcbiAgfSxcblxuICBhc3luYyBsb2FkQ29tcG9zaXRlKHNyYzogc3RyaW5nKTogUHJvbWlzZTxDb21wb3NpdGUuUmVzb3VyY2U+IHtcbiAgICBjb25zdCBjYWNoZWQgPSBmaW5kQ2FjaGVkKHNyYylcbiAgICBpZiAoY2FjaGVkKSByZXR1cm4gY2FjaGVkXG5cbiAgICBjb25zdCB7IGNvbnRlbnQgfSA9IGF3YWl0IHJlYWRGaWxlKHsgZmlsZU5hbWU6IHNyYyB9KVxuICAgIGNvbnN0IGNvbXBvc2l0ZSA9IGRlY29kZUZyb21CeXRlcyhjb250ZW50KVxuICAgIHJldHVybiBjYWNoZShzcmMsIGNvbXBvc2l0ZSlcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/internal/utf8.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Self-contained UTF-8 codec implementing the WHATWG Encoding Standard
+ * algorithms (https://encoding.spec.whatwg.org/), so SDK code never depends
+ * on the host providing `TextEncoder` / `TextDecoder` globals.
+ */
+export type DecodeUtf8Options = {
+    fatal?: boolean;
+    ignoreBOM?: boolean;
+};
+export declare function decodeUtf8(input: Uint8Array, options?: DecodeUtf8Options): string;
+export declare function encodeUtf8(input: string): Uint8Array;
+export declare function encodeUtf8Into(source: string, destination: Uint8Array): {
+    read: number;
+    written: number;
+};

package/internal/utf8.js

@@ -0,0 +1,172 @@
+/**
+ * Self-contained UTF-8 codec implementing the WHATWG Encoding Standard
+ * algorithms (https://encoding.spec.whatwg.org/), so SDK code never depends
+ * on the host providing `TextEncoder` / `TextDecoder` globals.
+ */
+const REPLACEMENT_CHARACTER = 0xfffd;
+export function decodeUtf8(input, options = {}) {
+    const fatal = options.fatal === true;
+    const start = !options.ignoreBOM && input.length >= 3 && input[0] === 0xef && input[1] === 0xbb && input[2] === 0xbf ? 3 : 0;
+    let result = '';
+    let pending = [];
+    let codePoint = 0;
+    let bytesNeeded = 0;
+    let bytesSeen = 0;
+    let lowerBoundary = 0x80;
+    let upperBoundary = 0xbf;
+    function emit(value) {
+        if (value <= 0xffff) {
+            pending.push(value);
+        }
+        else {
+            const offset = value - 0x10000;
+            pending.push(0xd800 + (offset >> 10), 0xdc00 + (offset & 0x3ff));
+        }
+        if (pending.length >= 4096) {
+            result += String.fromCharCode(...pending);
+            pending = [];
+        }
+    }
+    function malformed() {
+        if (fatal)
+            throw new TypeError('decodeUtf8: the encoded data is not valid utf-8');
+        emit(REPLACEMENT_CHARACTER);
+    }
+    for (let i = start; i < input.length; i++) {
+        const byte = input[i];
+        if (bytesNeeded === 0) {
+            if (byte <= 0x7f) {
+                emit(byte);
+            }
+            else if (byte >= 0xc2 && byte <= 0xdf) {
+                bytesNeeded = 1;
+                codePoint = byte & 0x1f;
+            }
+            else if (byte >= 0xe0 && byte <= 0xef) {
+                if (byte === 0xe0)
+                    lowerBoundary = 0xa0;
+                if (byte === 0xed)
+                    upperBoundary = 0x9f;
+                bytesNeeded = 2;
+                codePoint = byte & 0xf;
+            }
+            else if (byte >= 0xf0 && byte <= 0xf4) {
+                if (byte === 0xf0)
+                    lowerBoundary = 0x90;
+                if (byte === 0xf4)
+                    upperBoundary = 0x8f;
+                bytesNeeded = 3;
+                codePoint = byte & 0x7;
+            }
+            else {
+                malformed();
+            }
+        }
+        else if (byte < lowerBoundary || byte > upperBoundary) {
+            codePoint = 0;
+            bytesNeeded = 0;
+            bytesSeen = 0;
+            lowerBoundary = 0x80;
+            upperBoundary = 0xbf;
+            malformed();
+            // the spec prepends the byte back to the stream: it starts a new sequence
+            i--;
+        }
+        else {
+            lowerBoundary = 0x80;
+            upperBoundary = 0xbf;
+            codePoint = (codePoint << 6) | (byte & 0x3f);
+            if (++bytesSeen === bytesNeeded) {
+                emit(codePoint);
+                codePoint = 0;
+                bytesNeeded = 0;
+                bytesSeen = 0;
+            }
+        }
+    }
+    if (bytesNeeded !== 0)
+        malformed();
+    if (pending.length > 0)
+        result += String.fromCharCode(...pending);
+    return result;
+}
+export function encodeUtf8(input) {
+    const output = new Uint8Array(utf8ByteLength(input));
+    let offset = 0;
+    for (let i = 0; i < input.length; i++) {
+        const codePoint = codePointAt(input, i);
+        if (codePoint > 0xffff)
+            i++;
+        offset = writeCodePoint(output, offset, codePoint);
+    }
+    return output;
+}
+export function encodeUtf8Into(source, destination) {
+    let read = 0;
+    let written = 0;
+    for (let i = 0; i < source.length; i++) {
+        const codePoint = codePointAt(source, i);
+        const size = byteSize(codePoint);
+        if (written + size > destination.length)
+            break;
+        written = writeCodePoint(destination, written, codePoint);
+        if (codePoint > 0xffff) {
+            i++;
+            read += 2;
+        }
+        else {
+            read += 1;
+        }
+    }
+    return { read, written };
+}
+// Reads the code point at index, replacing unpaired surrogates with U+FFFD
+// (the USVString conversion `TextEncoder` mandates).
+function codePointAt(input, index) {
+    const first = input.charCodeAt(index);
+    if (first >= 0xd800 && first <= 0xdbff) {
+        const second = index + 1 < input.length ? input.charCodeAt(index + 1) : 0;
+        if (second >= 0xdc00 && second <= 0xdfff)
+            return 0x10000 + ((first - 0xd800) << 10) + (second - 0xdc00);
+        return REPLACEMENT_CHARACTER;
+    }
+    if (first >= 0xdc00 && first <= 0xdfff)
+        return REPLACEMENT_CHARACTER;
+    return first;
+}
+function byteSize(codePoint) {
+    return codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+}
+function utf8ByteLength(input) {
+    let length = 0;
+    for (let i = 0; i < input.length; i++) {
+        const codePoint = codePointAt(input, i);
+        if (codePoint > 0xffff)
+            i++;
+        length += byteSize(codePoint);
+    }
+    return length;
+}
+function writeCodePoint(output, offset, codePoint) {
+    let next = offset;
+    if (codePoint <= 0x7f) {
+        output[next++] = codePoint;
+    }
+    else if (codePoint <= 0x7ff) {
+        output[next++] = 0xc0 | (codePoint >> 6);
+        output[next++] = 0x80 | (codePoint & 0x3f);
+    }
+    else if (codePoint <= 0xffff) {
+        output[next++] = 0xe0 | (codePoint >> 12);
+        output[next++] = 0x80 | ((codePoint >> 6) & 0x3f);
+        output[next++] = 0x80 | (codePoint & 0x3f);
+    }
+    else {
+        output[next++] = 0xf0 | (codePoint >> 18);
+        output[next++] = 0x80 | ((codePoint >> 12) & 0x3f);
+        output[next++] = 0x80 | ((codePoint >> 6) & 0x3f);
+        output[next++] = 0x80 | (codePoint & 0x3f);
+    }
+    return next;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utf8.js","sourceRoot":"","sources":["../src/internal/utf8.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Self-contained UTF-8 codec implementing the WHATWG Encoding Standard\n * algorithms (https://encoding.spec.whatwg.org/), so SDK code never depends\n * on the host providing `TextEncoder` / `TextDecoder` globals.\n */\n\nconst REPLACEMENT_CHARACTER = 0xfffd\n\nexport type DecodeUtf8Options = {\n  fatal?: boolean\n  ignoreBOM?: boolean\n}\n\nexport function decodeUtf8(input: Uint8Array, options: DecodeUtf8Options = {}): string {\n  const fatal = options.fatal === true\n  const start =\n    !options.ignoreBOM && input.length >= 3 && input[0] === 0xef && input[1] === 0xbb && input[2] === 0xbf ? 3 : 0\n\n  let result = ''\n  let pending: number[] = []\n  let codePoint = 0\n  let bytesNeeded = 0\n  let bytesSeen = 0\n  let lowerBoundary = 0x80\n  let upperBoundary = 0xbf\n\n  function emit(value: number) {\n    if (value <= 0xffff) {\n      pending.push(value)\n    } else {\n      const offset = value - 0x10000\n      pending.push(0xd800 + (offset >> 10), 0xdc00 + (offset & 0x3ff))\n    }\n    if (pending.length >= 4096) {\n      result += String.fromCharCode(...pending)\n      pending = []\n    }\n  }\n\n  function malformed() {\n    if (fatal) throw new TypeError('decodeUtf8: the encoded data is not valid utf-8')\n    emit(REPLACEMENT_CHARACTER)\n  }\n\n  for (let i = start; i < input.length; i++) {\n    const byte = input[i]\n    if (bytesNeeded === 0) {\n      if (byte <= 0x7f) {\n        emit(byte)\n      } else if (byte >= 0xc2 && byte <= 0xdf) {\n        bytesNeeded = 1\n        codePoint = byte & 0x1f\n      } else if (byte >= 0xe0 && byte <= 0xef) {\n        if (byte === 0xe0) lowerBoundary = 0xa0\n        if (byte === 0xed) upperBoundary = 0x9f\n        bytesNeeded = 2\n        codePoint = byte & 0xf\n      } else if (byte >= 0xf0 && byte <= 0xf4) {\n        if (byte === 0xf0) lowerBoundary = 0x90\n        if (byte === 0xf4) upperBoundary = 0x8f\n        bytesNeeded = 3\n        codePoint = byte & 0x7\n      } else {\n        malformed()\n      }\n    } else if (byte < lowerBoundary || byte > upperBoundary) {\n      codePoint = 0\n      bytesNeeded = 0\n      bytesSeen = 0\n      lowerBoundary = 0x80\n      upperBoundary = 0xbf\n      malformed()\n      // the spec prepends the byte back to the stream: it starts a new sequence\n      i--\n    } else {\n      lowerBoundary = 0x80\n      upperBoundary = 0xbf\n      codePoint = (codePoint << 6) | (byte & 0x3f)\n      if (++bytesSeen === bytesNeeded) {\n        emit(codePoint)\n        codePoint = 0\n        bytesNeeded = 0\n        bytesSeen = 0\n      }\n    }\n  }\n  if (bytesNeeded !== 0) malformed()\n\n  if (pending.length > 0) result += String.fromCharCode(...pending)\n  return result\n}\n\nexport function encodeUtf8(input: string): Uint8Array {\n  const output = new Uint8Array(utf8ByteLength(input))\n  let offset = 0\n  for (let i = 0; i < input.length; i++) {\n    const codePoint = codePointAt(input, i)\n    if (codePoint > 0xffff) i++\n    offset = writeCodePoint(output, offset, codePoint)\n  }\n  return output\n}\n\nexport function encodeUtf8Into(source: string, destination: Uint8Array): { read: number; written: number } {\n  let read = 0\n  let written = 0\n  for (let i = 0; i < source.length; i++) {\n    const codePoint = codePointAt(source, i)\n    const size = byteSize(codePoint)\n    if (written + size > destination.length) break\n    written = writeCodePoint(destination, written, codePoint)\n    if (codePoint > 0xffff) {\n      i++\n      read += 2\n    } else {\n      read += 1\n    }\n  }\n  return { read, written }\n}\n\n// Reads the code point at index, replacing unpaired surrogates with U+FFFD\n// (the USVString conversion `TextEncoder` mandates).\nfunction codePointAt(input: string, index: number): number {\n  const first = input.charCodeAt(index)\n  if (first >= 0xd800 && first <= 0xdbff) {\n    const second = index + 1 < input.length ? input.charCodeAt(index + 1) : 0\n    if (second >= 0xdc00 && second <= 0xdfff) return 0x10000 + ((first - 0xd800) << 10) + (second - 0xdc00)\n    return REPLACEMENT_CHARACTER\n  }\n  if (first >= 0xdc00 && first <= 0xdfff) return REPLACEMENT_CHARACTER\n  return first\n}\n\nfunction byteSize(codePoint: number): number {\n  return codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4\n}\n\nfunction utf8ByteLength(input: string): number {\n  let length = 0\n  for (let i = 0; i < input.length; i++) {\n    const codePoint = codePointAt(input, i)\n    if (codePoint > 0xffff) i++\n    length += byteSize(codePoint)\n  }\n  return length\n}\n\nfunction writeCodePoint(output: Uint8Array, offset: number, codePoint: number): number {\n  let next = offset\n  if (codePoint <= 0x7f) {\n    output[next++] = codePoint\n  } else if (codePoint <= 0x7ff) {\n    output[next++] = 0xc0 | (codePoint >> 6)\n    output[next++] = 0x80 | (codePoint & 0x3f)\n  } else if (codePoint <= 0xffff) {\n    output[next++] = 0xe0 | (codePoint >> 12)\n    output[next++] = 0x80 | ((codePoint >> 6) & 0x3f)\n    output[next++] = 0x80 | (codePoint & 0x3f)\n  } else {\n    output[next++] = 0xf0 | (codePoint >> 18)\n    output[next++] = 0x80 | ((codePoint >> 12) & 0x3f)\n    output[next++] = 0x80 | ((codePoint >> 6) & 0x3f)\n    output[next++] = 0x80 | (codePoint & 0x3f)\n  }\n  return next\n}\n"]}

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@dcl/sdk",
   "description": "",
-  "version": "7.24.5",
+  "version": "7.24.6-29580060460.commit-06f0b7e",
   "author": "Decentraland",
   "dependencies": {
-    "@dcl/ecs": "7.24.5",
+    "@dcl/ecs": "7.24.6-29580060460.commit-06f0b7e",
     "@dcl/ecs-math": "2.1.0",
     "@dcl/explorer": "1.0.164509-20240802172549.commit-fb95b9b",
-    "@dcl/js-runtime": "7.24.5",
-    "@dcl/react-ecs": "7.24.5",
-    "@dcl/sdk-commands": "7.24.5",
-    "text-encoding": "0.7.0"
+    "@dcl/js-runtime": "7.24.6-29580060460.commit-06f0b7e",
+    "@dcl/react-ecs": "7.24.6-29580060460.commit-06f0b7e",
+    "@dcl/sdk-commands": "7.24.6-29580060460.commit-06f0b7e"
   },
   "keywords": [],
   "license": "Apache-2.0",
@@ -35,5 +34,5 @@
   },
   "types": "./index.d.ts",
   "typings": "./index.d.ts",
-  "commit": "fb197d38cdaec5a0de8d575b337ab142264644e7"
+  "commit": "06f0b7e70e2b43e9189a7f87de2a30db16ccb8e7"
 }

package/src/composite-provider.ts

@@ -1,6 +1,7 @@
 import { compositeFromLoader } from '~sdk/all-composites'
 import { readFile } from '~system/Runtime'
-import { Composite, getGlobal } from '@dcl/ecs'
+import { Composite } from '@dcl/ecs'
+import { decodeUtf8 } from './internal/utf8'
 
 const composites = new Map<string, Composite.Resource>()
 
@@ -28,16 +29,8 @@ function decodeFromBytes(content: Uint8Array): Composite.Definition {
   // The first-byte check is a fast path; a JSON.parse failure falls back to fromBinary
   // because a protobuf message can also begin with 0x7b.
   if (content[0] === 0x7b /* '{' */) {
-    const TD = getGlobal<new () => { decode(input: Uint8Array): string }>('TextDecoder')
-    if (!TD) {
-      throw new Error(
-        'loadComposite: TextDecoder is not available in this runtime. ' +
-          'Use a .composite.bin file, or import `@dcl/sdk/ethereum-provider` ' +
-          'to install the TextEncoder/TextDecoder polyfill.'
-      )
-    }
     try {
-      return Composite.fromJson(JSON.parse(new TD().decode(content)))
+      return Composite.fromJson(JSON.parse(decodeUtf8(content, { fatal: true })))
     } catch {
       return Composite.fromBinary(content)
     }

package/src/internal/utf8.ts

@@ -0,0 +1,167 @@
+/**
+ * Self-contained UTF-8 codec implementing the WHATWG Encoding Standard
+ * algorithms (https://encoding.spec.whatwg.org/), so SDK code never depends
+ * on the host providing `TextEncoder` / `TextDecoder` globals.
+ */
+
+const REPLACEMENT_CHARACTER = 0xfffd
+
+export type DecodeUtf8Options = {
+  fatal?: boolean
+  ignoreBOM?: boolean
+}
+
+export function decodeUtf8(input: Uint8Array, options: DecodeUtf8Options = {}): string {
+  const fatal = options.fatal === true
+  const start =
+    !options.ignoreBOM && input.length >= 3 && input[0] === 0xef && input[1] === 0xbb && input[2] === 0xbf ? 3 : 0
+
+  let result = ''
+  let pending: number[] = []
+  let codePoint = 0
+  let bytesNeeded = 0
+  let bytesSeen = 0
+  let lowerBoundary = 0x80
+  let upperBoundary = 0xbf
+
+  function emit(value: number) {
+    if (value <= 0xffff) {
+      pending.push(value)
+    } else {
+      const offset = value - 0x10000
+      pending.push(0xd800 + (offset >> 10), 0xdc00 + (offset & 0x3ff))
+    }
+    if (pending.length >= 4096) {
+      result += String.fromCharCode(...pending)
+      pending = []
+    }
+  }
+
+  function malformed() {
+    if (fatal) throw new TypeError('decodeUtf8: the encoded data is not valid utf-8')
+    emit(REPLACEMENT_CHARACTER)
+  }
+
+  for (let i = start; i < input.length; i++) {
+    const byte = input[i]
+    if (bytesNeeded === 0) {
+      if (byte <= 0x7f) {
+        emit(byte)
+      } else if (byte >= 0xc2 && byte <= 0xdf) {
+        bytesNeeded = 1
+        codePoint = byte & 0x1f
+      } else if (byte >= 0xe0 && byte <= 0xef) {
+        if (byte === 0xe0) lowerBoundary = 0xa0
+        if (byte === 0xed) upperBoundary = 0x9f
+        bytesNeeded = 2
+        codePoint = byte & 0xf
+      } else if (byte >= 0xf0 && byte <= 0xf4) {
+        if (byte === 0xf0) lowerBoundary = 0x90
+        if (byte === 0xf4) upperBoundary = 0x8f
+        bytesNeeded = 3
+        codePoint = byte & 0x7
+      } else {
+        malformed()
+      }
+    } else if (byte < lowerBoundary || byte > upperBoundary) {
+      codePoint = 0
+      bytesNeeded = 0
+      bytesSeen = 0
+      lowerBoundary = 0x80
+      upperBoundary = 0xbf
+      malformed()
+      // the spec prepends the byte back to the stream: it starts a new sequence
+      i--
+    } else {
+      lowerBoundary = 0x80
+      upperBoundary = 0xbf
+      codePoint = (codePoint << 6) | (byte & 0x3f)
+      if (++bytesSeen === bytesNeeded) {
+        emit(codePoint)
+        codePoint = 0
+        bytesNeeded = 0
+        bytesSeen = 0
+      }
+    }
+  }
+  if (bytesNeeded !== 0) malformed()
+
+  if (pending.length > 0) result += String.fromCharCode(...pending)
+  return result
+}
+
+export function encodeUtf8(input: string): Uint8Array {
+  const output = new Uint8Array(utf8ByteLength(input))
+  let offset = 0
+  for (let i = 0; i < input.length; i++) {
+    const codePoint = codePointAt(input, i)
+    if (codePoint > 0xffff) i++
+    offset = writeCodePoint(output, offset, codePoint)
+  }
+  return output
+}
+
+export function encodeUtf8Into(source: string, destination: Uint8Array): { read: number; written: number } {
+  let read = 0
+  let written = 0
+  for (let i = 0; i < source.length; i++) {
+    const codePoint = codePointAt(source, i)
+    const size = byteSize(codePoint)
+    if (written + size > destination.length) break
+    written = writeCodePoint(destination, written, codePoint)
+    if (codePoint > 0xffff) {
+      i++
+      read += 2
+    } else {
+      read += 1
+    }
+  }
+  return { read, written }
+}
+
+// Reads the code point at index, replacing unpaired surrogates with U+FFFD
+// (the USVString conversion `TextEncoder` mandates).
+function codePointAt(input: string, index: number): number {
+  const first = input.charCodeAt(index)
+  if (first >= 0xd800 && first <= 0xdbff) {
+    const second = index + 1 < input.length ? input.charCodeAt(index + 1) : 0
+    if (second >= 0xdc00 && second <= 0xdfff) return 0x10000 + ((first - 0xd800) << 10) + (second - 0xdc00)
+    return REPLACEMENT_CHARACTER
+  }
+  if (first >= 0xdc00 && first <= 0xdfff) return REPLACEMENT_CHARACTER
+  return first
+}
+
+function byteSize(codePoint: number): number {
+  return codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4
+}
+
+function utf8ByteLength(input: string): number {
+  let length = 0
+  for (let i = 0; i < input.length; i++) {
+    const codePoint = codePointAt(input, i)
+    if (codePoint > 0xffff) i++
+    length += byteSize(codePoint)
+  }
+  return length
+}
+
+function writeCodePoint(output: Uint8Array, offset: number, codePoint: number): number {
+  let next = offset
+  if (codePoint <= 0x7f) {
+    output[next++] = codePoint
+  } else if (codePoint <= 0x7ff) {
+    output[next++] = 0xc0 | (codePoint >> 6)
+    output[next++] = 0x80 | (codePoint & 0x3f)
+  } else if (codePoint <= 0xffff) {
+    output[next++] = 0xe0 | (codePoint >> 12)
+    output[next++] = 0x80 | ((codePoint >> 6) & 0x3f)
+    output[next++] = 0x80 | (codePoint & 0x3f)
+  } else {
+    output[next++] = 0xf0 | (codePoint >> 18)
+    output[next++] = 0x80 | ((codePoint >> 12) & 0x3f)
+    output[next++] = 0x80 | ((codePoint >> 6) & 0x3f)
+    output[next++] = 0x80 | (codePoint & 0x3f)
+  }
+  return next
+}

package/src/text-codec.ts

@@ -1,23 +1,70 @@
-import TextEncodingPolyfill from 'text-encoding'
 import { setGlobalPolyfill } from '@dcl/ecs'
+import { decodeUtf8, encodeUtf8, encodeUtf8Into } from './internal/utf8'
 
 /**
- * Install the `TextEncoder` / `TextDecoder` polyfill on `globalThis`.
+ * WHATWG-shaped `TextEncoder` / `TextDecoder` over the SDK's own UTF-8 codec.
  *
- * The QuickJS scene runtime ships no native `TextEncoder` / `TextDecoder`, yet
- * `compositeProvider.loadComposite` decodes `.composite` JSON file bytes via
- * `TextDecoder`. Callers that load composites at runtime (e.g. `@dcl/asset-packs`'
- * `SPAWN_ENTITY`) must install this first.
+ * UTF-8 is the only supported encoding: the decoder throws a `RangeError` for
+ * any other label instead of silently mis-decoding, and rejects `{ stream: true }`.
+ */
+
+// Labels the WHATWG Encoding Standard maps to utf-8.
+const UTF8_LABELS = ['unicode-1-1-utf-8', 'unicode11utf8', 'unicode20utf8', 'utf-8', 'utf8', 'x-unicode20utf8']
+
+function toUint8Array(input?: ArrayBuffer | ArrayBufferView): Uint8Array {
+  if (input === undefined) return new Uint8Array(0)
+  if (input instanceof Uint8Array) return input
+  if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength)
+  return new Uint8Array(input)
+}
+
+export class TextEncoder {
+  readonly encoding = 'utf-8'
+
+  encode(input: string = ''): Uint8Array {
+    return encodeUtf8(String(input))
+  }
+
+  encodeInto(source: string, destination: Uint8Array): { read: number; written: number } {
+    return encodeUtf8Into(String(source), destination)
+  }
+}
+
+export class TextDecoder {
+  readonly encoding = 'utf-8'
+  readonly fatal: boolean
+  readonly ignoreBOM: boolean
+
+  constructor(label: string = 'utf-8', options: { fatal?: boolean; ignoreBOM?: boolean } = {}) {
+    // the spec strips ASCII whitespace only, so String.prototype.trim is too wide
+    const normalized = String(label)
+      .replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '')
+      .toLowerCase()
+    if (!UTF8_LABELS.includes(normalized)) {
+      throw new RangeError(`TextDecoder: only utf-8 is supported, got "${label}"`)
+    }
+    this.fatal = options.fatal === true
+    this.ignoreBOM = options.ignoreBOM === true
+  }
+
+  decode(input?: ArrayBuffer | ArrayBufferView, options: { stream?: boolean } = {}): string {
+    if (options.stream) throw new TypeError('TextDecoder: streaming is not supported')
+    return decodeUtf8(toUint8Array(input), { fatal: this.fatal, ignoreBOM: this.ignoreBOM })
+  }
+}
+
+/**
+ * Install `TextEncoder` / `TextDecoder` on `globalThis` where the runtime does
+ * not provide them (native implementations always win over these polyfills).
  *
  * Exposed from the lean `@dcl/sdk/text-codec` subpath so consumers can install
- * the polyfill without pulling in the ethereum provider, and without bundling
- * `text-encoding` into scenes that never reach this module.
+ * the polyfill without pulling in the ethereum provider.
  */
 // NOTE: this function mutates globalThis — it is NOT pure. Do not annotate
 // with /* @__PURE__ */; minifiers would treat the call as dead code and drop
-// the polyfill installation, breaking runtime callers like
-// compositeProvider.loadComposite that rely on globalThis.TextDecoder.
+// the polyfill installation, breaking third-party code that relies on
+// globalThis.TextDecoder.
 export function polyfillTextEncoder() {
-  setGlobalPolyfill('TextEncoder', TextEncodingPolyfill.TextEncoder)
-  setGlobalPolyfill('TextDecoder', TextEncodingPolyfill.TextDecoder)
+  setGlobalPolyfill('TextEncoder', TextEncoder)
+  setGlobalPolyfill('TextDecoder', TextDecoder)
 }

package/text-codec.d.ts

@@ -1,13 +1,28 @@
+export declare class TextEncoder {
+    readonly encoding = "utf-8";
+    encode(input?: string): Uint8Array;
+    encodeInto(source: string, destination: Uint8Array): {
+        read: number;
+        written: number;
+    };
+}
+export declare class TextDecoder {
+    readonly encoding = "utf-8";
+    readonly fatal: boolean;
+    readonly ignoreBOM: boolean;
+    constructor(label?: string, options?: {
+        fatal?: boolean;
+        ignoreBOM?: boolean;
+    });
+    decode(input?: ArrayBuffer | ArrayBufferView, options?: {
+        stream?: boolean;
+    }): string;
+}
 /**
- * Install the `TextEncoder` / `TextDecoder` polyfill on `globalThis`.
- *
- * The QuickJS scene runtime ships no native `TextEncoder` / `TextDecoder`, yet
- * `compositeProvider.loadComposite` decodes `.composite` JSON file bytes via
- * `TextDecoder`. Callers that load composites at runtime (e.g. `@dcl/asset-packs`'
- * `SPAWN_ENTITY`) must install this first.
+ * Install `TextEncoder` / `TextDecoder` on `globalThis` where the runtime does
+ * not provide them (native implementations always win over these polyfills).
  *
  * Exposed from the lean `@dcl/sdk/text-codec` subpath so consumers can install
- * the polyfill without pulling in the ethereum provider, and without bundling
- * `text-encoding` into scenes that never reach this module.
+ * the polyfill without pulling in the ethereum provider.
  */
 export declare function polyfillTextEncoder(): void;

package/text-codec.js

@@ -1,23 +1,65 @@
-import TextEncodingPolyfill from 'text-encoding';
 import { setGlobalPolyfill } from '@dcl/ecs';
+import { decodeUtf8, encodeUtf8, encodeUtf8Into } from './internal/utf8';
 /**
- * Install the `TextEncoder` / `TextDecoder` polyfill on `globalThis`.
+ * WHATWG-shaped `TextEncoder` / `TextDecoder` over the SDK's own UTF-8 codec.
  *
- * The QuickJS scene runtime ships no native `TextEncoder` / `TextDecoder`, yet
- * `compositeProvider.loadComposite` decodes `.composite` JSON file bytes via
- * `TextDecoder`. Callers that load composites at runtime (e.g. `@dcl/asset-packs`'
- * `SPAWN_ENTITY`) must install this first.
+ * UTF-8 is the only supported encoding: the decoder throws a `RangeError` for
+ * any other label instead of silently mis-decoding, and rejects `{ stream: true }`.
+ */
+// Labels the WHATWG Encoding Standard maps to utf-8.
+const UTF8_LABELS = ['unicode-1-1-utf-8', 'unicode11utf8', 'unicode20utf8', 'utf-8', 'utf8', 'x-unicode20utf8'];
+function toUint8Array(input) {
+    if (input === undefined)
+        return new Uint8Array(0);
+    if (input instanceof Uint8Array)
+        return input;
+    if (ArrayBuffer.isView(input))
+        return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    return new Uint8Array(input);
+}
+export class TextEncoder {
+    constructor() {
+        this.encoding = 'utf-8';
+    }
+    encode(input = '') {
+        return encodeUtf8(String(input));
+    }
+    encodeInto(source, destination) {
+        return encodeUtf8Into(String(source), destination);
+    }
+}
+export class TextDecoder {
+    constructor(label = 'utf-8', options = {}) {
+        this.encoding = 'utf-8';
+        // the spec strips ASCII whitespace only, so String.prototype.trim is too wide
+        const normalized = String(label)
+            .replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '')
+            .toLowerCase();
+        if (!UTF8_LABELS.includes(normalized)) {
+            throw new RangeError(`TextDecoder: only utf-8 is supported, got "${label}"`);
+        }
+        this.fatal = options.fatal === true;
+        this.ignoreBOM = options.ignoreBOM === true;
+    }
+    decode(input, options = {}) {
+        if (options.stream)
+            throw new TypeError('TextDecoder: streaming is not supported');
+        return decodeUtf8(toUint8Array(input), { fatal: this.fatal, ignoreBOM: this.ignoreBOM });
+    }
+}
+/**
+ * Install `TextEncoder` / `TextDecoder` on `globalThis` where the runtime does
+ * not provide them (native implementations always win over these polyfills).
  *
  * Exposed from the lean `@dcl/sdk/text-codec` subpath so consumers can install
- * the polyfill without pulling in the ethereum provider, and without bundling
- * `text-encoding` into scenes that never reach this module.
+ * the polyfill without pulling in the ethereum provider.
  */
 // NOTE: this function mutates globalThis — it is NOT pure. Do not annotate
 // with /* @__PURE__ */; minifiers would treat the call as dead code and drop
-// the polyfill installation, breaking runtime callers like
-// compositeProvider.loadComposite that rely on globalThis.TextDecoder.
+// the polyfill installation, breaking third-party code that relies on
+// globalThis.TextDecoder.
 export function polyfillTextEncoder() {
-    setGlobalPolyfill('TextEncoder', TextEncodingPolyfill.TextEncoder);
-    setGlobalPolyfill('TextDecoder', TextEncodingPolyfill.TextDecoder);
+    setGlobalPolyfill('TextEncoder', TextEncoder);
+    setGlobalPolyfill('TextDecoder', TextDecoder);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/src/ethereum-provider/text-encoding.d.ts

@@ -1,4 +0,0 @@
-declare module 'text-encoding' {
-  export const TextEncoder: any
-  export const TextDecoder: any
-}