node-osc 11.2.0 → 11.2.1

package/.github/workflows/bump-version.yml

@@ -35,14 +35,14 @@ jobs:
     # run that runs on: tag. (Using the GitHub token would
     # not run the workflow to prevent infinite recursion.)
     - name: Check out source
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         ssh-key: ${{ secrets.DEPLOY_KEY }}
 
     - name: Setup Node.js
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v6
       with:
-        node-version: 22
+        node-version: 24
         cache: 'npm'
 
     - name: Install npm packages

package/.github/workflows/create-release.yml

@@ -17,11 +17,11 @@ jobs:
       id-token: write
     steps:
     - name: Checkout source
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
     - name: Setup node
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v6
       with:
-        node-version: 22
+        node-version: 24
         registry-url: 'https://registry.npmjs.org'
         cache: npm
     - name: Install latest npm
@@ -39,7 +39,7 @@ jobs:
       contents: write
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
       - name: Create Release
         run: gh release create ${{ github.ref }} --generate-notes
         env:

package/.github/workflows/nodejs.yml

@@ -14,16 +14,16 @@ jobs:
   run-tests:
     strategy:
       matrix:
-        node-version: ['24', '22', '20']
+        node-version: ['25', '24', '22', '20']
         os: [ubuntu-latest, macos-latest, windows-latest]
 
     runs-on: ${{ matrix.os }}
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v6
       with:
         node-version: ${{ matrix.node-version }}
         cache: 'npm'

package/dist/lib/Client.js

@@ -156,7 +156,7 @@ class Client extends node_events.EventEmitter {
     if (message instanceof Array) {
       message = {
         address: message[0],
-        args: message.splice(1)
+        args: message.slice(1)
       };
     }
     

package/dist/lib/Message.js

@@ -111,7 +111,9 @@ class Message {
     let argOut;
     switch (typeof arg) {
     case 'object':
-      if (arg instanceof Array) {
+      if (Buffer.isBuffer(arg)) {
+        this.args.push(arg);
+      } else if (arg instanceof Array) {
         arg.forEach(a => this.append(a));
       } else if (arg.type) {
         if (typeTags[arg.type]) arg.type = typeTags[arg.type];

package/dist/lib/osc.js

@@ -8,8 +8,9 @@ var node_buffer = require('node:buffer');
 
 function padString(str) {
   const nullTerminated = str + '\0';
-  const padding = 4 - (nullTerminated.length % 4);
-  return nullTerminated + '\0'.repeat(padding === 4 ? 0 : padding);
+  const byteLength = node_buffer.Buffer.byteLength(nullTerminated);
+  const padding = (4 - (byteLength % 4)) % 4;
+  return nullTerminated + '\0'.repeat(padding);
 }
 
 function readString(buffer, offset) {

package/dist/test/lib/osc.js

@@ -8,8 +8,9 @@ var node_buffer = require('node:buffer');
 
 function padString(str) {
   const nullTerminated = str + '\0';
-  const padding = 4 - (nullTerminated.length % 4);
-  return nullTerminated + '\0'.repeat(padding === 4 ? 0 : padding);
+  const byteLength = node_buffer.Buffer.byteLength(nullTerminated);
+  const padding = (4 - (byteLength % 4)) % 4;
+  return nullTerminated + '\0'.repeat(padding);
 }
 
 function readString(buffer, offset) {

package/dist/test/test-client.js

@@ -23,6 +23,28 @@ tap.test('client: with array', (t) => {
   });
 });
 
+tap.test('client: array is not mutated when sent', (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(3);
+
+  const originalArray = ['/test', 0, 1, 'testing', true];
+  const expectedArray = ['/test', 0, 1, 'testing', true];
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+    // Verify the original array was not mutated
+    t.same(originalArray, expectedArray, 'Original array should not be mutated');
+  });
+
+  client.send(originalArray, (err) => {
+    t.error(err, 'there should be no error');
+    client.close();
+  });
+});
+
 tap.test('client: with string', (t) => {
   const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
   const client = new nodeOsc.Client('127.0.0.1', t.context.port);

package/dist/test/test-encode-decode.js

@@ -847,3 +847,362 @@ tap.test('encode and decode: type "boolean" with false value', (t) => {
   t.equal(decoded.args[0].value, false);
   t.end();
 });
+
+// Tests for UTF-8 string padding to 4-byte boundaries
+// The padString function ensures OSC strings are padded based on byte length
+// (not character count) to handle multi-byte UTF-8 correctly
+
+tap.test('encode and decode: UTF-8 string padding - ASCII 1 char', (t) => {
+  // 1 byte + 1 null terminator = 2 bytes, needs 2 padding bytes to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'a' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'a', 'should correctly encode and decode single ASCII character');
+  
+  // Verify the string is properly padded in the buffer
+  // Address "/test" is 5 bytes + 1 null = 6 bytes, padded to 8 bytes
+  // Type tag ",s" is 2 bytes + 1 null = 3 bytes, padded to 4 bytes
+  // String "a" is 1 byte + 1 null = 2 bytes, padded to 4 bytes
+  const expectedMinLength = 8 + 4 + 4; // 16 bytes minimum
+  t.ok(buffer.length >= expectedMinLength, 'buffer should contain properly padded string');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - ASCII 2 chars', (t) => {
+  // 2 bytes + 1 null = 3 bytes, needs 1 padding byte to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'ab' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'ab', 'should correctly encode and decode 2-byte string');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - ASCII 3 chars', (t) => {
+  // 3 bytes + 1 null terminator = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'abc' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'abc', 'should correctly encode and decode 3-char ASCII string');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - ASCII 5 chars', (t) => {
+  // 5 bytes + 1 null terminator = 6 bytes, needs 2 padding bytes to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'hello' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'hello', 'should correctly encode and decode 5-char ASCII string');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - ASCII 6 chars', (t) => {
+  // 6 bytes + 1 null = 7 bytes, needs 1 padding byte to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'abcdef' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'abcdef', 'should correctly encode and decode 6-byte string');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - ASCII 7 chars', (t) => {
+  // 7 bytes + 1 null terminator = 8 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'testing' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'testing', 'should correctly encode and decode 7-char ASCII string');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - empty string', (t) => {
+  // 0 bytes + 1 null terminator = 1 byte, needs 3 padding bytes to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, '', 'should correctly encode and decode empty string');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - emoji character', (t) => {
+  // Emoji '😀' is 4 bytes in UTF-8 + 1 null = 5 bytes, needs 3 padding to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '😀' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, '😀', 'should correctly encode and decode emoji character');
+  
+  // Verify byte length calculation is correct
+  const emojiByteLength = Buffer.byteLength('😀');
+  t.equal(emojiByteLength, 4, 'emoji should be 4 bytes in UTF-8');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - Japanese character', (t) => {
+  // Japanese 'あ' is 3 bytes in UTF-8 + 1 null = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'あ' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'あ', 'should correctly encode and decode Japanese character');
+  
+  const japaneseByteLength = Buffer.byteLength('あ');
+  t.equal(japaneseByteLength, 3, 'Japanese character should be 3 bytes in UTF-8');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - Chinese character', (t) => {
+  // Chinese '中' is 3 bytes in UTF-8 + 1 null = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '中' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, '中', 'should correctly encode and decode Chinese character');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - mixed ASCII and emoji', (t) => {
+  // 'a' (1 byte) + '😀' (4 bytes) + 'b' (1 byte) = 6 bytes + 1 null = 7 bytes
+  // needs 1 padding byte to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'a😀b' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'a😀b', 'should correctly encode and decode mixed ASCII and emoji');
+  
+  const mixedByteLength = Buffer.byteLength('a😀b');
+  t.equal(mixedByteLength, 6, 'mixed string should be 6 bytes in UTF-8');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - Japanese string', (t) => {
+  // 'こんにちは' (Hello in Japanese) - 5 characters, each 3 bytes = 15 bytes
+  // 15 bytes + 1 null = 16 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'こんにちは' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'こんにちは', 'should correctly encode and decode Japanese string');
+  
+  const japaneseStringByteLength = Buffer.byteLength('こんにちは');
+  t.equal(japaneseStringByteLength, 15, 'Japanese string should be 15 bytes in UTF-8');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - accented characters', (t) => {
+  // 'café' - 4 characters but 'é' is 2 bytes in UTF-8
+  // 'c' (1) + 'a' (1) + 'f' (1) + 'é' (2) = 5 bytes + 1 null = 6 bytes
+  // needs 2 padding bytes to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'café' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'café', 'should correctly encode and decode accented string');
+  
+  const accentedByteLength = Buffer.byteLength('café');
+  t.equal(accentedByteLength, 5, 'café should be 5 bytes in UTF-8');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - multiple strings', (t) => {
+  // Test multiple strings with different byte lengths in one message
+  const message = {
+    oscType: 'message',
+    address: '/multi',
+    args: [
+      { type: 'string', value: 'a' },      // 1 byte + null
+      { type: 'string', value: '😀' },     // 4 bytes + null
+      { type: 'string', value: 'abc' },    // 3 bytes + null
+      { type: 'string', value: '' }        // 0 bytes + null
+    ]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args.length, 4, 'should have 4 arguments');
+  t.equal(decoded.args[0].value, 'a', 'first string should be correct');
+  t.equal(decoded.args[1].value, '😀', 'second string should be correct');
+  t.equal(decoded.args[2].value, 'abc', 'third string should be correct');
+  t.equal(decoded.args[3].value, '', 'fourth string should be correct');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - address with emoji', (t) => {
+  // OSC addresses can also contain UTF-8 characters and must be properly padded
+  const message = {
+    oscType: 'message',
+    address: '/test/😀',
+    args: [{ type: 'string', value: 'data' }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.address, '/test/😀', 'should correctly encode and decode address with emoji');
+  t.equal(decoded.args[0].value, 'data', 'should correctly encode and decode argument');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - long mixed string', (t) => {
+  // Test a longer string with mixed content
+  const longString = 'Hello 世界 🌍! Testing UTF-8 encoding with café and naïve.';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: longString }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, longString, 'should correctly encode and decode long mixed UTF-8 string');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - special characters', (t) => {
+  // Test various special characters that may have different byte lengths
+  const specialChars = '!@#$%^&*()_+-=[]{}|;:,.<>?/~`';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: specialChars }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, specialChars, 'should correctly encode and decode special ASCII characters');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - control characters', (t) => {
+  // Test control characters
+  const controlChars = 'line1\nline2\ttab';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: controlChars }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, controlChars, 'should correctly encode and decode strings with newlines and tabs');
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - surrogate pairs', (t) => {
+  // Test various emoji that are 4-byte UTF-8 sequences
+  const emojis = '🎉🎊🎈🎁';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: emojis }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, emojis, 'should correctly encode and decode multiple 4-byte emoji');
+  
+  const emojisByteLength = Buffer.byteLength(emojis);
+  t.equal(emojisByteLength, 16, 'four 4-byte emoji should total 16 bytes');
+  
+  t.end();
+});
+
+tap.test('encode and decode: UTF-8 string padding - zero-width characters', (t) => {
+  // Test zero-width joiner and other special Unicode characters
+  const zwj = 'a\u200Db'; // zero-width joiner
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: zwj }]
+  };
+  
+  const buffer = nodeOsc.encode(message);
+  const decoded = nodeOsc.decode(buffer);
+  
+  t.equal(decoded.args[0].value, zwj, 'should correctly encode and decode strings with zero-width characters');
+  t.end();
+});

package/dist/test/test-message.js

@@ -173,6 +173,29 @@ tap.test('message: blob', (t) => {
   });
 });
 
+tap.test('message: Buffer as blob', (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+  const m = new nodeOsc.Message('/address');
+  const buf = Buffer.from('test buffer data');
+  // Directly append Buffer without wrapping in object
+  m.append(buf);
+
+  oscServer.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We received the buffer payload: ${msg}`);
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
 // test('message: timetag', (t) => {
 //   const oscServer = new osc.Server(3333, '127.0.0.1');
 //   const client = new osc.Client('127.0.0.1', 3333);
@@ -192,6 +215,130 @@ tap.test('message: blob', (t) => {
 //   });
 // });
 
+tap.test('message: Buffer with multiple arguments', (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+  const m = new nodeOsc.Message('/address');
+  const buf1 = Buffer.from('first');
+  const buf2 = Buffer.from('second');
+
+  m.append('string');
+  m.append(42);
+  m.append(buf1);
+  m.append(3.14);
+  m.append(buf2);
+
+  oscServer.on('message', (msg) => {
+    t.equal(msg[0], '/address', 'Address matches');
+    t.equal(msg[1], 'string', 'String matches');
+    t.equal(msg[2], 42, 'Integer matches');
+    t.same(msg[3], buf1, 'First buffer matches');
+    t.equal(round(msg[4]), 3.14, 'Float matches');
+    t.same(msg[5], buf2, 'Second buffer matches');
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
+tap.test('message: Buffer in constructor', (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+  const buf = Buffer.from('constructor buffer');
+  const m = new nodeOsc.Message('/address', 'test', buf, 123);
+
+  oscServer.on('message', (msg) => {
+    const expected = [
+      '/address',
+      'test',
+      buf,
+      123
+    ];
+    t.same(msg, expected, `We received the constructor buffer payload: ${msg}`);
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
+tap.test('message: Buffer in array', (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+  const m = new nodeOsc.Message('/address');
+  const buf1 = Buffer.from('array1');
+  const buf2 = Buffer.from('array2');
+
+  m.append([buf1, 'string', buf2, 456]);
+
+  oscServer.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf1,
+      'string',
+      buf2,
+      456
+    ];
+    t.same(msg, expected, `We received the array with buffers: ${msg}`);
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
+tap.test('message: empty Buffer', (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+  const m = new nodeOsc.Message('/address');
+  const buf = Buffer.from('');
+  
+  m.append(buf);
+
+  oscServer.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We received the empty buffer: ${msg}`);
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
+tap.test('message: large Buffer', (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+  const m = new nodeOsc.Message('/address');
+  const buf = Buffer.alloc(1024, 'x');
+  
+  m.append(buf);
+
+  oscServer.on('message', (msg) => {
+    t.equal(msg[0], '/address', 'Address matches');
+    t.ok(Buffer.isBuffer(msg[1]), 'Second element is a Buffer');
+    t.equal(msg[1].length, 1024, 'Buffer size matches');
+    t.same(msg[1], buf, 'Buffer content matches');
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
 tap.test('message: error', (t) => {
   const m = new nodeOsc.Message('/address');
   t.plan(2);

package/dist/test/test-promises.js

@@ -22,6 +22,28 @@ tap.test('client: send with promise - array', async (t) => {
   await client.close();
 });
 
+tap.test('client: array is not mutated when sent with promise', async (t) => {
+  const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(2);
+
+  const originalArray = ['/test', 0, 1, 'testing', true];
+  const expectedArray = ['/test', 0, 1, 'testing', true];
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+  });
+
+  await client.send(originalArray);
+  
+  // Verify the original array was not mutated
+  t.same(originalArray, expectedArray, 'Original array should not be mutated');
+  
+  await client.close();
+});
+
 tap.test('client: send with promise - string', async (t) => {
   const oscServer = new nodeOsc.Server(t.context.port, '127.0.0.1');
   const client = new nodeOsc.Client('127.0.0.1', t.context.port);

package/lib/Client.mjs

@@ -154,7 +154,7 @@ class Client extends EventEmitter {
     if (message instanceof Array) {
       message = {
         address: message[0],
-        args: message.splice(1)
+        args: message.slice(1)
       };
     }
     

package/lib/Message.mjs

@@ -109,7 +109,9 @@ class Message {
     let argOut;
     switch (typeof arg) {
     case 'object':
-      if (arg instanceof Array) {
+      if (Buffer.isBuffer(arg)) {
+        this.args.push(arg);
+      } else if (arg instanceof Array) {
         arg.forEach(a => this.append(a));
       } else if (arg.type) {
         if (typeTags[arg.type]) arg.type = typeTags[arg.type];

package/lib/osc.mjs

@@ -7,8 +7,9 @@ import { Buffer } from 'node:buffer';
 
 function padString(str) {
   const nullTerminated = str + '\0';
-  const padding = 4 - (nullTerminated.length % 4);
-  return nullTerminated + '\0'.repeat(padding === 4 ? 0 : padding);
+  const byteLength = Buffer.byteLength(nullTerminated);
+  const padding = (4 - (byteLength % 4)) % 4;
+  return nullTerminated + '\0'.repeat(padding);
 }
 
 function readString(buffer, offset) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-osc",
   "description": "pyOSC inspired library for sending and receiving OSC messages",
-  "version": "11.2.0",
+  "version": "11.2.1",
   "exports": {
     "types": "./types/index.d.mts",
     "require": "./dist/lib/index.js",

package/rollup.config.mjs

@@ -69,6 +69,7 @@ function walkTest(config) {
       'node:fs',
       'node:path',
       'node:url',
+      'node:timers/promises',
       'node-osc',
       'tap',
       '#decode'

package/test/test-client.mjs

@@ -22,6 +22,28 @@ test('client: with array', (t) => {
   });
 });
 
+test('client: array is not mutated when sent', (t) => {
+  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const client = new Client('127.0.0.1', t.context.port);
+
+  t.plan(3);
+
+  const originalArray = ['/test', 0, 1, 'testing', true];
+  const expectedArray = ['/test', 0, 1, 'testing', true];
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+    // Verify the original array was not mutated
+    t.same(originalArray, expectedArray, 'Original array should not be mutated');
+  });
+
+  client.send(originalArray, (err) => {
+    t.error(err, 'there should be no error');
+    client.close();
+  });
+});
+
 test('client: with string', (t) => {
   const oscServer = new Server(t.context.port, '127.0.0.1');
   const client = new Client('127.0.0.1', t.context.port);

package/test/test-encode-decode.mjs

@@ -845,3 +845,362 @@ test('encode and decode: type "boolean" with false value', (t) => {
   t.equal(decoded.args[0].value, false);
   t.end();
 });
+
+// Tests for UTF-8 string padding to 4-byte boundaries
+// The padString function ensures OSC strings are padded based on byte length
+// (not character count) to handle multi-byte UTF-8 correctly
+
+test('encode and decode: UTF-8 string padding - ASCII 1 char', (t) => {
+  // 1 byte + 1 null terminator = 2 bytes, needs 2 padding bytes to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'a' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'a', 'should correctly encode and decode single ASCII character');
+  
+  // Verify the string is properly padded in the buffer
+  // Address "/test" is 5 bytes + 1 null = 6 bytes, padded to 8 bytes
+  // Type tag ",s" is 2 bytes + 1 null = 3 bytes, padded to 4 bytes
+  // String "a" is 1 byte + 1 null = 2 bytes, padded to 4 bytes
+  const expectedMinLength = 8 + 4 + 4; // 16 bytes minimum
+  t.ok(buffer.length >= expectedMinLength, 'buffer should contain properly padded string');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 2 chars', (t) => {
+  // 2 bytes + 1 null = 3 bytes, needs 1 padding byte to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'ab' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'ab', 'should correctly encode and decode 2-byte string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 3 chars', (t) => {
+  // 3 bytes + 1 null terminator = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'abc' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'abc', 'should correctly encode and decode 3-char ASCII string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 5 chars', (t) => {
+  // 5 bytes + 1 null terminator = 6 bytes, needs 2 padding bytes to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'hello' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'hello', 'should correctly encode and decode 5-char ASCII string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 6 chars', (t) => {
+  // 6 bytes + 1 null = 7 bytes, needs 1 padding byte to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'abcdef' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'abcdef', 'should correctly encode and decode 6-byte string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - ASCII 7 chars', (t) => {
+  // 7 bytes + 1 null terminator = 8 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'testing' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'testing', 'should correctly encode and decode 7-char ASCII string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - empty string', (t) => {
+  // 0 bytes + 1 null terminator = 1 byte, needs 3 padding bytes to reach 4-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, '', 'should correctly encode and decode empty string');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - emoji character', (t) => {
+  // Emoji '😀' is 4 bytes in UTF-8 + 1 null = 5 bytes, needs 3 padding to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '😀' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, '😀', 'should correctly encode and decode emoji character');
+  
+  // Verify byte length calculation is correct
+  const emojiByteLength = Buffer.byteLength('😀');
+  t.equal(emojiByteLength, 4, 'emoji should be 4 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - Japanese character', (t) => {
+  // Japanese 'あ' is 3 bytes in UTF-8 + 1 null = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'あ' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'あ', 'should correctly encode and decode Japanese character');
+  
+  const japaneseByteLength = Buffer.byteLength('あ');
+  t.equal(japaneseByteLength, 3, 'Japanese character should be 3 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - Chinese character', (t) => {
+  // Chinese '中' is 3 bytes in UTF-8 + 1 null = 4 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: '中' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, '中', 'should correctly encode and decode Chinese character');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - mixed ASCII and emoji', (t) => {
+  // 'a' (1 byte) + '😀' (4 bytes) + 'b' (1 byte) = 6 bytes + 1 null = 7 bytes
+  // needs 1 padding byte to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'a😀b' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'a😀b', 'should correctly encode and decode mixed ASCII and emoji');
+  
+  const mixedByteLength = Buffer.byteLength('a😀b');
+  t.equal(mixedByteLength, 6, 'mixed string should be 6 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - Japanese string', (t) => {
+  // 'こんにちは' (Hello in Japanese) - 5 characters, each 3 bytes = 15 bytes
+  // 15 bytes + 1 null = 16 bytes, needs 0 padding (already aligned)
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'こんにちは' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'こんにちは', 'should correctly encode and decode Japanese string');
+  
+  const japaneseStringByteLength = Buffer.byteLength('こんにちは');
+  t.equal(japaneseStringByteLength, 15, 'Japanese string should be 15 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - accented characters', (t) => {
+  // 'café' - 4 characters but 'é' is 2 bytes in UTF-8
+  // 'c' (1) + 'a' (1) + 'f' (1) + 'é' (2) = 5 bytes + 1 null = 6 bytes
+  // needs 2 padding bytes to reach 8-byte boundary
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: 'café' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, 'café', 'should correctly encode and decode accented string');
+  
+  const accentedByteLength = Buffer.byteLength('café');
+  t.equal(accentedByteLength, 5, 'café should be 5 bytes in UTF-8');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - multiple strings', (t) => {
+  // Test multiple strings with different byte lengths in one message
+  const message = {
+    oscType: 'message',
+    address: '/multi',
+    args: [
+      { type: 'string', value: 'a' },      // 1 byte + null
+      { type: 'string', value: '😀' },     // 4 bytes + null
+      { type: 'string', value: 'abc' },    // 3 bytes + null
+      { type: 'string', value: '' }        // 0 bytes + null
+    ]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args.length, 4, 'should have 4 arguments');
+  t.equal(decoded.args[0].value, 'a', 'first string should be correct');
+  t.equal(decoded.args[1].value, '😀', 'second string should be correct');
+  t.equal(decoded.args[2].value, 'abc', 'third string should be correct');
+  t.equal(decoded.args[3].value, '', 'fourth string should be correct');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - address with emoji', (t) => {
+  // OSC addresses can also contain UTF-8 characters and must be properly padded
+  const message = {
+    oscType: 'message',
+    address: '/test/😀',
+    args: [{ type: 'string', value: 'data' }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.address, '/test/😀', 'should correctly encode and decode address with emoji');
+  t.equal(decoded.args[0].value, 'data', 'should correctly encode and decode argument');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - long mixed string', (t) => {
+  // Test a longer string with mixed content
+  const longString = 'Hello 世界 🌍! Testing UTF-8 encoding with café and naïve.';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: longString }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, longString, 'should correctly encode and decode long mixed UTF-8 string');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - special characters', (t) => {
+  // Test various special characters that may have different byte lengths
+  const specialChars = '!@#$%^&*()_+-=[]{}|;:,.<>?/~`';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: specialChars }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, specialChars, 'should correctly encode and decode special ASCII characters');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - control characters', (t) => {
+  // Test control characters
+  const controlChars = 'line1\nline2\ttab';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: controlChars }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, controlChars, 'should correctly encode and decode strings with newlines and tabs');
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - surrogate pairs', (t) => {
+  // Test various emoji that are 4-byte UTF-8 sequences
+  const emojis = '🎉🎊🎈🎁';
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: emojis }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, emojis, 'should correctly encode and decode multiple 4-byte emoji');
+  
+  const emojisByteLength = Buffer.byteLength(emojis);
+  t.equal(emojisByteLength, 16, 'four 4-byte emoji should total 16 bytes');
+  
+  t.end();
+});
+
+test('encode and decode: UTF-8 string padding - zero-width characters', (t) => {
+  // Test zero-width joiner and other special Unicode characters
+  const zwj = 'a\u200Db'; // zero-width joiner
+  const message = {
+    oscType: 'message',
+    address: '/test',
+    args: [{ type: 'string', value: zwj }]
+  };
+  
+  const buffer = encode(message);
+  const decoded = decode(buffer);
+  
+  t.equal(decoded.args[0].value, zwj, 'should correctly encode and decode strings with zero-width characters');
+  t.end();
+});

package/test/test-message.mjs

@@ -172,6 +172,29 @@ test('message: blob', (t) => {
   });
 });
 
+test('message: Buffer as blob', (t) => {
+  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const client = new Client('127.0.0.1', t.context.port);
+  const m = new Message('/address');
+  const buf = Buffer.from('test buffer data');
+  // Directly append Buffer without wrapping in object
+  m.append(buf);
+
+  oscServer.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We received the buffer payload: ${msg}`);
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
 // test('message: timetag', (t) => {
 //   const oscServer = new osc.Server(3333, '127.0.0.1');
 //   const client = new osc.Client('127.0.0.1', 3333);
@@ -191,6 +214,130 @@ test('message: blob', (t) => {
 //   });
 // });
 
+test('message: Buffer with multiple arguments', (t) => {
+  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const client = new Client('127.0.0.1', t.context.port);
+  const m = new Message('/address');
+  const buf1 = Buffer.from('first');
+  const buf2 = Buffer.from('second');
+
+  m.append('string');
+  m.append(42);
+  m.append(buf1);
+  m.append(3.14);
+  m.append(buf2);
+
+  oscServer.on('message', (msg) => {
+    t.equal(msg[0], '/address', 'Address matches');
+    t.equal(msg[1], 'string', 'String matches');
+    t.equal(msg[2], 42, 'Integer matches');
+    t.same(msg[3], buf1, 'First buffer matches');
+    t.equal(round(msg[4]), 3.14, 'Float matches');
+    t.same(msg[5], buf2, 'Second buffer matches');
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
+test('message: Buffer in constructor', (t) => {
+  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const client = new Client('127.0.0.1', t.context.port);
+  const buf = Buffer.from('constructor buffer');
+  const m = new Message('/address', 'test', buf, 123);
+
+  oscServer.on('message', (msg) => {
+    const expected = [
+      '/address',
+      'test',
+      buf,
+      123
+    ];
+    t.same(msg, expected, `We received the constructor buffer payload: ${msg}`);
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
+test('message: Buffer in array', (t) => {
+  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const client = new Client('127.0.0.1', t.context.port);
+  const m = new Message('/address');
+  const buf1 = Buffer.from('array1');
+  const buf2 = Buffer.from('array2');
+
+  m.append([buf1, 'string', buf2, 456]);
+
+  oscServer.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf1,
+      'string',
+      buf2,
+      456
+    ];
+    t.same(msg, expected, `We received the array with buffers: ${msg}`);
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
+test('message: empty Buffer', (t) => {
+  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const client = new Client('127.0.0.1', t.context.port);
+  const m = new Message('/address');
+  const buf = Buffer.from('');
+  
+  m.append(buf);
+
+  oscServer.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We received the empty buffer: ${msg}`);
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
+test('message: large Buffer', (t) => {
+  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const client = new Client('127.0.0.1', t.context.port);
+  const m = new Message('/address');
+  const buf = Buffer.alloc(1024, 'x');
+  
+  m.append(buf);
+
+  oscServer.on('message', (msg) => {
+    t.equal(msg[0], '/address', 'Address matches');
+    t.ok(Buffer.isBuffer(msg[1]), 'Second element is a Buffer');
+    t.equal(msg[1].length, 1024, 'Buffer size matches');
+    t.same(msg[1], buf, 'Buffer content matches');
+    oscServer.close();
+    t.end();
+  });
+
+  client.send(m, () => {
+    client.close();
+  });
+});
+
 test('message: error', (t) => {
   const m = new Message('/address');
   t.plan(2);

package/test/test-promises.mjs

@@ -21,6 +21,28 @@ test('client: send with promise - array', async (t) => {
   await client.close();
 });
 
+test('client: array is not mutated when sent with promise', async (t) => {
+  const oscServer = new Server(t.context.port, '127.0.0.1');
+  const client = new Client('127.0.0.1', t.context.port);
+
+  t.plan(2);
+
+  const originalArray = ['/test', 0, 1, 'testing', true];
+  const expectedArray = ['/test', 0, 1, 'testing', true];
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+  });
+
+  await client.send(originalArray);
+  
+  // Verify the original array was not mutated
+  t.same(originalArray, expectedArray, 'Original array should not be mutated');
+  
+  await client.close();
+});
+
 test('client: send with promise - string', async (t) => {
   const oscServer = new Server(t.context.port, '127.0.0.1');
   const client = new Client('127.0.0.1', t.context.port);

package/types/Message.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Message.d.mts","sourceRoot":"","sources":["../lib/Message.mjs"],"names":[],"mappings":";AAyBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACE;;;;;;;;;;;;;;OAcG;IACH,qBAZW,MAAM,WACH,GAAC,EAAA,EAed;IAHC,gBAAwB;IACxB,gBAAsB;IACtB,YAAgB;IAGlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,YA7BW,GAAC,QA2DX;CACF"}
+{"version":3,"file":"Message.d.mts","sourceRoot":"","sources":["../lib/Message.mjs"],"names":[],"mappings":";AAyBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACE;;;;;;;;;;;;;;OAcG;IACH,qBAZW,MAAM,WACH,GAAC,EAAA,EAed;IAHC,gBAAwB;IACxB,gBAAsB;IACtB,YAAgB;IAGlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,YA7BW,GAAC,QA6DX;CACF"}

package/types/osc.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"osc.d.mts","sourceRoot":"","sources":["../lib/osc.mjs"],"names":[],"mappings":"AA+MA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,sCAtBa,MAAM,CA4BlB;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,+BAzBW,MAAM,OAgChB;uBAlUsB,aAAa"}
+{"version":3,"file":"osc.d.mts","sourceRoot":"","sources":["../lib/osc.mjs"],"names":[],"mappings":"AAgNA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,sCAtBa,MAAM,CA4BlB;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,+BAzBW,MAAM,OAgChB;uBAnUsB,aAAa"}