@ac-kit/format-osc 0.0.0-stage → 0.1.1

package/dist/packet/_write-osc-packet.js

@@ -0,0 +1,155 @@
+import { encodeTextUtf8 } from "@ac-kit/core";
+import { assertOscTimeTag_ } from "../time-tag/_ntp.js";
+import { BUNDLE_MARKER_ } from "./_bundle-marker.js";
+const INT32_MIN_ = -2147483648;
+const INT32_MAX_ = 2147483647;
+const INT64_MIN_ = -(2n ** 63n);
+const INT64_MAX_ = 2n ** 63n - 1n;
+const TYPE_TAGS_ = {
+    int32: "i",
+    float32: "f",
+    string: "s",
+    blob: "b",
+    int64: "h",
+    timeTag: "t",
+    float64: "d",
+    symbol: "S",
+    char: "c",
+    rgba: "r",
+    midi: "m",
+    true: "T",
+    false: "F",
+    nil: "N",
+    impulse: "I",
+    array: "[",
+};
+/**
+ * Appends `packet` to `writer` — the single implementation of the OSC write
+ * grammar, OSC 1.0 §"OSC Packets" through §"OSC Bundles".
+ *
+ * A type tag string is always written, `,` alone for no arguments, as OSC 1.1
+ * requires. Recursion depth is the caller's own nesting; nothing here bounds
+ * it.
+ */
+export function writeOscPacket_(writer, packet) {
+    if (packet.kind === "message") {
+        if (!packet.address.startsWith("/")) {
+            throw new RangeError(`encodeOscPacket: address must begin with "/", got ${JSON.stringify(packet.address)}`);
+        }
+        writer.writePadded(encodeOscString_(packet.address, "address"), 1);
+        writer.writePadded(encodeTextUtf8(`,${typeTagsOf_(packet.arguments)}`), 1);
+        writeArguments_(writer, packet.arguments);
+        return;
+    }
+    assertOscTimeTag_(packet.timeTag, "encodeOscPacket: bundle time tag");
+    writer.writePadded(BUNDLE_MARKER_, 0);
+    writer.writeUint32(packet.timeTag.seconds);
+    writer.writeUint32(packet.timeTag.fraction);
+    for (const element of packet.elements) {
+        const sizeOffset = writer.allocate(4);
+        const start = writer.length;
+        writeOscPacket_(writer, element);
+        writer.patchUint32(sizeOffset, writer.length - start);
+    }
+}
+function typeTagsOf_(items) {
+    let tags = "";
+    for (const item of items) {
+        tags += TYPE_TAGS_[item.type];
+        if (item.type === "array") {
+            tags += `${typeTagsOf_(item.items)}]`;
+        }
+    }
+    return tags;
+}
+function writeArguments_(writer, items) {
+    for (const item of items) {
+        switch (item.type) {
+            case "int32":
+                if (!Number.isInteger(item.value) ||
+                    item.value < INT32_MIN_ ||
+                    item.value > INT32_MAX_) {
+                    throw new RangeError(`encodeOscPacket: int32 must be an integer in -2^31..2^31-1, got ${item.value}`);
+                }
+                writer.writeUint32(item.value);
+                break;
+            case "float32":
+                writer.writeFloat32(item.value);
+                break;
+            case "string":
+            case "symbol":
+                writer.writePadded(encodeOscString_(item.value, item.type), 1);
+                break;
+            case "blob":
+                if (item.value.length > INT32_MAX_) {
+                    throw new RangeError(`encodeOscPacket: blob of ${item.value.length} bytes exceeds the int32 size field`);
+                }
+                writer.writeUint32(item.value.length);
+                writer.writePadded(item.value, 0);
+                break;
+            case "int64":
+                if (item.value < INT64_MIN_ || item.value > INT64_MAX_) {
+                    throw new RangeError(`encodeOscPacket: int64 must be in -2^63..2^63-1, got ${item.value}`);
+                }
+                writer.writeUint64(BigInt.asUintN(64, item.value));
+                break;
+            case "timeTag":
+                assertOscTimeTag_(item.value, "encodeOscPacket: timeTag argument");
+                writer.writeUint32(item.value.seconds);
+                writer.writeUint32(item.value.fraction);
+                break;
+            case "float64":
+                writer.writeFloat64(item.value);
+                break;
+            case "char":
+                writer.writeUint32(charCodePoint_(item.value));
+                break;
+            case "rgba":
+                writer.writeBytes4(byte_(item.red, "rgba red"), byte_(item.green, "rgba green"), byte_(item.blue, "rgba blue"), byte_(item.alpha, "rgba alpha"));
+                break;
+            case "midi":
+                writer.writeBytes4(byte_(item.port, "midi port"), byte_(item.status, "midi status"), byte_(item.data1, "midi data1"), byte_(item.data2, "midi data2"));
+                break;
+            case "true":
+            case "false":
+            case "nil":
+            case "impulse":
+                break;
+            case "array":
+                writeArguments_(writer, item.items);
+                break;
+            default:
+                item;
+        }
+    }
+}
+/**
+ * UTF-8 bytes of an OSC-string. A NUL would end the string early on the wire,
+ * and a lone surrogate would be replaced by U+FFFD, so both are refused rather
+ * than sent as something else.
+ */
+function encodeOscString_(text, what) {
+    if (text.includes("\0")) {
+        throw new RangeError(`encodeOscPacket: ${what} contains a NUL character`);
+    }
+    if (!text.isWellFormed()) {
+        throw new RangeError(`encodeOscPacket: ${what} contains a lone surrogate`);
+    }
+    return encodeTextUtf8(text);
+}
+function charCodePoint_(value) {
+    const codePoint = value.codePointAt(0);
+    if (codePoint === undefined ||
+        value.length !== (codePoint > 0xffff ? 2 : 1) ||
+        (codePoint >= 0xd800 && codePoint <= 0xdfff)) {
+        throw new RangeError(`encodeOscPacket: char must be exactly one code point, got ${JSON.stringify(value)}`);
+    }
+    return codePoint;
+}
+function byte_(value, what) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xff) {
+        throw new RangeError(`encodeOscPacket: ${what} must be an integer in 0..255, got ${value}`);
+    }
+    return value;
+}
+//# sourceMappingURL=_write-osc-packet.js.map

package/dist/packet/_write-osc-packet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_write-osc-packet.js","sourceRoot":"","sources":["../../src/packet/_write-osc-packet.ts"],"names":[],"mappings":"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"}

package/dist/packet/decode-osc-packet.d.ts

@@ -0,0 +1,48 @@
+import type { OscPacket } from "./osc-packet.js";
+/** Options for {@link decodeOscPacket} and the decoders built on it. */
+export type DecodeOscPacketOptions = {
+    /**
+     * How many bundles and arrays may enclose one another, counted together: a
+     * top-level bundle is one level, an array in a message inside it a second. 0
+     * refuses every bundle and array. Defaults to 32 — no OSC implementation in
+     * use nests more than a few levels, and the bound keeps a hostile packet from
+     * exhausting the stack. Recursion depth, and so stack use, grows with it.
+     */
+    maxDepth?: number;
+};
+/**
+ * Decodes one whole OSC packet: the bytes of a datagram, or the content of a
+ * stream frame. For a transport, prefer the codecs, which handle the framing
+ * and report malformed packets as decode results.
+ *
+ * `bytes` must be exactly one packet; nothing after it is ignored. The decoder
+ * is strict where OSC is a network boundary:
+ *
+ * - Strings and blobs must be padded with NUL bytes, and a packet or bundle
+ *   element must be a multiple of 4 bytes long;
+ * - An unknown type tag is an error, since the size of its data is unknowable;
+ * - Every bundle element must fit its bundle, and every argument its message;
+ * - Strings are decoded as UTF-8 and must be valid. OSC 1.0 specifies ASCII, of
+ *   which UTF-8 is a superset, and UTF-8 is what OSC 1.1 implementations send.
+ *   A byte order mark is kept as U+FEFF.
+ *
+ * A message with no type tag string, which OSC 1.0 asks receivers to tolerate
+ * from older senders, decodes with no arguments when nothing follows its
+ * address. If bytes do follow, their types cannot be known, and the message is
+ * an error rather than silently losing them.
+ *
+ * Time is O(n) in `bytes.length`. The result copies every blob, so it never
+ * aliases `bytes`.
+ *
+ * @example
+ * 	```ts
+ * 	decodeOscPacket(datagram);
+ * 	// { kind: "message", address: "/oscillator/4/frequency", arguments: [{ type: "float32", value: 440 }] }
+ * 	```;
+ *
+ * @throws {OscPacketError} When `bytes` is not a well-formed packet; its
+ *   `offset` is the byte offset in `bytes` where decoding gave up.
+ * @throws {RangeError} When `options.maxDepth` is not a non-negative integer.
+ */
+export declare function decodeOscPacket(bytes: Uint8Array, options?: DecodeOscPacketOptions): OscPacket;
+//# sourceMappingURL=decode-osc-packet.d.ts.map

package/dist/packet/decode-osc-packet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-osc-packet.d.ts","sourceRoot":"","sources":["../../src/packet/decode-osc-packet.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,wEAAwE;AACxE,MAAM,MAAM,sBAAsB,GAAG;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,UAAU,EACjB,OAAO,CAAC,EAAE,sBAAsB,GAC9B,SAAS,CAEX"}

package/dist/packet/decode-osc-packet.js

@@ -0,0 +1,39 @@
+import { readOscPacket_, resolveMaxDepth_ } from "./_read-osc-packet.js";
+/**
+ * Decodes one whole OSC packet: the bytes of a datagram, or the content of a
+ * stream frame. For a transport, prefer the codecs, which handle the framing
+ * and report malformed packets as decode results.
+ *
+ * `bytes` must be exactly one packet; nothing after it is ignored. The decoder
+ * is strict where OSC is a network boundary:
+ *
+ * - Strings and blobs must be padded with NUL bytes, and a packet or bundle
+ *   element must be a multiple of 4 bytes long;
+ * - An unknown type tag is an error, since the size of its data is unknowable;
+ * - Every bundle element must fit its bundle, and every argument its message;
+ * - Strings are decoded as UTF-8 and must be valid. OSC 1.0 specifies ASCII, of
+ *   which UTF-8 is a superset, and UTF-8 is what OSC 1.1 implementations send.
+ *   A byte order mark is kept as U+FEFF.
+ *
+ * A message with no type tag string, which OSC 1.0 asks receivers to tolerate
+ * from older senders, decodes with no arguments when nothing follows its
+ * address. If bytes do follow, their types cannot be known, and the message is
+ * an error rather than silently losing them.
+ *
+ * Time is O(n) in `bytes.length`. The result copies every blob, so it never
+ * aliases `bytes`.
+ *
+ * @example
+ * 	```ts
+ * 	decodeOscPacket(datagram);
+ * 	// { kind: "message", address: "/oscillator/4/frequency", arguments: [{ type: "float32", value: 440 }] }
+ * 	```;
+ *
+ * @throws {OscPacketError} When `bytes` is not a well-formed packet; its
+ *   `offset` is the byte offset in `bytes` where decoding gave up.
+ * @throws {RangeError} When `options.maxDepth` is not a non-negative integer.
+ */
+export function decodeOscPacket(bytes, options) {
+    return readOscPacket_(bytes, resolveMaxDepth_(options?.maxDepth));
+}
+//# sourceMappingURL=decode-osc-packet.js.map

package/dist/packet/decode-osc-packet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-osc-packet.js","sourceRoot":"","sources":["../../src/packet/decode-osc-packet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAezE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,eAAe,CAC9B,KAAiB,EACjB,OAAgC;IAEhC,OAAO,cAAc,CAAC,KAAK,EAAE,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;AACnE,CAAC"}

package/dist/packet/encode-osc-packet.d.ts

@@ -0,0 +1,32 @@
+import type { OscPacket } from "./osc-packet.js";
+/**
+ * Encodes one OSC packet: the bytes of a datagram, or the content of a stream
+ * frame. For a transport, prefer the codecs, which add the framing it needs.
+ *
+ * Every message gets a type tag string — `,` alone when it has no arguments.
+ * Strings are written as UTF-8 with their NUL terminator, strings and blobs are
+ * padded with NUL bytes to a multiple of 4, and numbers are big-endian. A
+ * `float32` argument is rounded to binary32 as `Math.fround` would, so 1.234
+ * reads back as 1.2339999675750732.
+ *
+ * Time and memory are O(n) in the encoded size.
+ *
+ * @example
+ * 	```ts
+ * 	encodeOscPacket({
+ * 		kind: "message",
+ * 		address: "/oscillator/4/frequency",
+ * 		arguments: [{ type: "float32", value: 440 }],
+ * 	}); // 32 bytes, ending 2c 66 00 00 43 dc 00 00
+ * 	```;
+ *
+ * @returns A fresh buffer, a multiple of 4 bytes long.
+ * @throws {RangeError} When the packet cannot be written as given: an address
+ *   not beginning with `/`; a string, symbol or address containing U+0000 or a
+ *   lone surrogate; an `int32` that is not an integer in −2^31..2^31 − 1; an
+ *   `int64` outside −2^63..2^63 − 1; a time tag field that is not an unsigned
+ *   32-bit integer; a `char` that is not exactly one code point; an `rgba` or
+ *   `midi` byte that is not an integer in 0–255.
+ */
+export declare function encodeOscPacket(packet: OscPacket): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=encode-osc-packet.d.ts.map

package/dist/packet/encode-osc-packet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-osc-packet.d.ts","sourceRoot":"","sources":["../../src/packet/encode-osc-packet.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,CAK1E"}

package/dist/packet/encode-osc-packet.js

@@ -0,0 +1,37 @@
+import { OscWriter_ } from "./_osc-writer.js";
+import { writeOscPacket_ } from "./_write-osc-packet.js";
+/**
+ * Encodes one OSC packet: the bytes of a datagram, or the content of a stream
+ * frame. For a transport, prefer the codecs, which add the framing it needs.
+ *
+ * Every message gets a type tag string — `,` alone when it has no arguments.
+ * Strings are written as UTF-8 with their NUL terminator, strings and blobs are
+ * padded with NUL bytes to a multiple of 4, and numbers are big-endian. A
+ * `float32` argument is rounded to binary32 as `Math.fround` would, so 1.234
+ * reads back as 1.2339999675750732.
+ *
+ * Time and memory are O(n) in the encoded size.
+ *
+ * @example
+ * 	```ts
+ * 	encodeOscPacket({
+ * 		kind: "message",
+ * 		address: "/oscillator/4/frequency",
+ * 		arguments: [{ type: "float32", value: 440 }],
+ * 	}); // 32 bytes, ending 2c 66 00 00 43 dc 00 00
+ * 	```;
+ *
+ * @returns A fresh buffer, a multiple of 4 bytes long.
+ * @throws {RangeError} When the packet cannot be written as given: an address
+ *   not beginning with `/`; a string, symbol or address containing U+0000 or a
+ *   lone surrogate; an `int32` that is not an integer in −2^31..2^31 − 1; an
+ *   `int64` outside −2^63..2^63 − 1; a time tag field that is not an unsigned
+ *   32-bit integer; a `char` that is not exactly one code point; an `rgba` or
+ *   `midi` byte that is not an integer in 0–255.
+ */
+export function encodeOscPacket(packet) {
+    const writer = new OscWriter_();
+    writeOscPacket_(writer, packet);
+    return writer.finish();
+}
+//# sourceMappingURL=encode-osc-packet.js.map

package/dist/packet/encode-osc-packet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-osc-packet.js","sourceRoot":"","sources":["../../src/packet/encode-osc-packet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,eAAe,CAAC,MAAiB;IAChD,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;IAChC,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC,OAAO,MAAM,CAAC,MAAM,EAAE,CAAC;AACxB,CAAC"}

package/dist/packet/osc-packet.d.ts

@@ -0,0 +1,104 @@
+import type { OscTimeTag } from "../time-tag/osc-time-tag.js";
+/**
+ * One argument of an OSC message, discriminated by `type`. Each variant names
+ * the type tag it travels under:
+ *
+ * - `int32` (`i`) — a signed 32-bit integer, −2^31 to 2^31 − 1.
+ * - `float32` (`f`) — an IEEE 754 binary32; a `number` is rounded to it on
+ *   encode, as `Math.fround` would.
+ * - `string` (`s`) — text, sent as UTF-8; never contains U+0000.
+ * - `blob` (`b`) — arbitrary bytes.
+ * - `int64` (`h`) — a signed 64-bit integer, as a `bigint`.
+ * - `timeTag` (`t`) — an NTP time tag.
+ * - `float64` (`d`) — an IEEE 754 binary64.
+ * - `symbol` (`S`) — text like `string`, for systems that tell symbols apart.
+ * - `char` (`c`) — one character, sent as its code point in 32 bits.
+ * - `rgba` (`r`) — a 32-bit colour, each channel 0–255.
+ * - `midi` (`m`) — a 4-byte MIDI message: port, status and two data bytes, each
+ *   0–255.
+ * - `true` (`T`), `false` (`F`), `nil` (`N`), `impulse` (`I`) — values carried by
+ *   the tag alone. `impulse` is OSC 1.1's name for the tag OSC 1.0 calls
+ *   Infinitum.
+ * - `array` (`[` … `]`) — a nested list of arguments.
+ *
+ * The types beyond `i`, `f`, `s` and `b` are the ones OSC 1.0 lists as
+ * non-standard and OSC 1.1 makes standard.
+ */
+export type OscArgument = {
+    type: "int32";
+    value: number;
+} | {
+    type: "float32";
+    value: number;
+} | {
+    type: "string";
+    value: string;
+} | {
+    type: "blob";
+    value: Uint8Array;
+} | {
+    type: "int64";
+    value: bigint;
+} | {
+    type: "timeTag";
+    value: OscTimeTag;
+} | {
+    type: "float64";
+    value: number;
+} | {
+    type: "symbol";
+    value: string;
+} | {
+    type: "char";
+    /** Exactly one Unicode code point; OSC 1.0 calls for ASCII. */
+    value: string;
+} | {
+    type: "rgba";
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+} | {
+    type: "midi";
+    port: number;
+    status: number;
+    data1: number;
+    data2: number;
+} | {
+    type: "true";
+} | {
+    type: "false";
+} | {
+    type: "nil";
+} | {
+    type: "impulse";
+} | {
+    type: "array";
+    items: OscArgument[];
+};
+/**
+ * An OSC message: an address pattern and the arguments for the methods it
+ * matches.
+ */
+export type OscMessage = {
+    kind: "message";
+    /**
+     * The OSC address pattern, beginning with `/`. It may hold the wildcards of
+     * OSC address pattern matching; this package carries it as text.
+     */
+    address: string;
+    arguments: OscArgument[];
+};
+/**
+ * An OSC bundle: packets to be acted on together, at the instant `timeTag`
+ * names.
+ */
+export type OscBundle = {
+    kind: "bundle";
+    timeTag: OscTimeTag;
+    /** Messages and nested bundles, in order. */
+    elements: OscPacket[];
+};
+/** The unit of OSC transmission: a message or a bundle. */
+export type OscPacket = OscMessage | OscBundle;
+//# sourceMappingURL=osc-packet.d.ts.map

package/dist/packet/osc-packet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"osc-packet.d.ts","sourceRoot":"","sources":["../../src/packet/osc-packet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,WAAW,GACpB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACjC;IACA,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;CACb,GACD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACzE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACf;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE,CAAC;AAE3C;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,EAAE,CAAC;CACzB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,UAAU,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,EAAE,SAAS,EAAE,CAAC;CACtB,CAAC;AAEF,2DAA2D;AAC3D,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC"}

package/dist/packet/osc-packet.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=osc-packet.js.map

package/dist/packet/osc-packet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"osc-packet.js","sourceRoot":"","sources":["../../src/packet/osc-packet.ts"],"names":[],"mappings":""}

package/dist/time-tag/_ntp.d.ts

@@ -0,0 +1,13 @@
+import type { OscTimeTag } from "./osc-time-tag.js";
+/** 2^32: one NTP era in seconds, and one second in `fraction` units. */
+export declare const TWO_POW_32_ = 4294967296;
+/** 2^31: `seconds` values at or above it are in NTP era 0 (RFC 4330 §3). */
+export declare const TWO_POW_31_ = 2147483648;
+/** Seconds from 1900-01-01T00:00:00Z to the Unix epoch, 1970-01-01T00:00:00Z. */
+export declare const NTP_UNIX_OFFSET_SECONDS_ = 2208988800;
+/**
+ * Throws a `RangeError` unless both fields of `tag` are unsigned 32-bit
+ * integers. `what` names the value in the message.
+ */
+export declare function assertOscTimeTag_(tag: OscTimeTag, what: string): void;
+//# sourceMappingURL=_ntp.d.ts.map

package/dist/time-tag/_ntp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_ntp.d.ts","sourceRoot":"","sources":["../../src/time-tag/_ntp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,wEAAwE;AACxE,eAAO,MAAM,WAAW,aAAgB,CAAC;AAEzC,4EAA4E;AAC5E,eAAO,MAAM,WAAW,aAAgB,CAAC;AAEzC,iFAAiF;AACjF,eAAO,MAAM,wBAAwB,aAAgB,CAAC;AAEtD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAMrE"}

package/dist/time-tag/_ntp.js

@@ -0,0 +1,19 @@
+/** 2^32: one NTP era in seconds, and one second in `fraction` units. */
+export const TWO_POW_32_ = 4294967296;
+/** 2^31: `seconds` values at or above it are in NTP era 0 (RFC 4330 §3). */
+export const TWO_POW_31_ = 2147483648;
+/** Seconds from 1900-01-01T00:00:00Z to the Unix epoch, 1970-01-01T00:00:00Z. */
+export const NTP_UNIX_OFFSET_SECONDS_ = 2208988800;
+/**
+ * Throws a `RangeError` unless both fields of `tag` are unsigned 32-bit
+ * integers. `what` names the value in the message.
+ */
+export function assertOscTimeTag_(tag, what) {
+    if (!isUint32_(tag.seconds) || !isUint32_(tag.fraction)) {
+        throw new RangeError(`${what}: seconds and fraction must be integers in 0..2^32-1, got ${tag.seconds} and ${tag.fraction}`);
+    }
+}
+function isUint32_(value) {
+    return Number.isInteger(value) && value >= 0 && value < TWO_POW_32_;
+}
+//# sourceMappingURL=_ntp.js.map

package/dist/time-tag/_ntp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_ntp.js","sourceRoot":"","sources":["../../src/time-tag/_ntp.ts"],"names":[],"mappings":"AAEA,wEAAwE;AACxE,MAAM,CAAC,MAAM,WAAW,GAAG,UAAa,CAAC;AAEzC,4EAA4E;AAC5E,MAAM,CAAC,MAAM,WAAW,GAAG,UAAa,CAAC;AAEzC,iFAAiF;AACjF,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAa,CAAC;AAEtD;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAe,EAAE,IAAY;IAC9D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzD,MAAM,IAAI,UAAU,CACnB,GAAG,IAAI,6DAA6D,GAAG,CAAC,OAAO,QAAQ,GAAG,CAAC,QAAQ,EAAE,CACrG,CAAC;IACH,CAAC;AACF,CAAC;AAED,SAAS,SAAS,CAAC,KAAa;IAC/B,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,GAAG,WAAW,CAAC;AACrE,CAAC"}

package/dist/time-tag/osc-time-tag-from-date.d.ts

@@ -0,0 +1,29 @@
+import type { OscTimeTag } from "./osc-time-tag.js";
+/**
+ * Converts an instant to the OSC time tag naming it.
+ *
+ * The 32-bit `seconds` field wraps every 2^32 s (about 136 years), so a tag is
+ * read with the RFC 4330 §3 rule: a value with its most significant bit set is
+ * in NTP era 0 (from 1900), one with it clear is in era 1 (from
+ * 2036-02-07T06:28:16Z). The instants that rule can name, and so the ones this
+ * accepts, run from 1968-01-20T03:14:08Z inclusive to 2104-02-26T09:42:24Z
+ * exclusive.
+ *
+ * The fraction is rounded to the nearest 2^-32 s, so a whole number of
+ * milliseconds survives {@link oscTimeTagToDate} exactly. A fractional `number`
+ * keeps its sub-millisecond part as far as `number` resolves it.
+ *
+ * @example
+ * 	```ts
+ * 	oscTimeTagFromDate(0); // { seconds: 2208988800, fraction: 0 }
+ * 	oscTimeTagFromDate(new Date("2036-02-07T06:28:16.500Z")); // { seconds: 0, fraction: 2147483648 }
+ * 	```;
+ *
+ * @param date - The instant, as a `Date` or as milliseconds since the Unix
+ *   epoch (`Date.now()`, `performance.timeOrigin + performance.now()`).
+ * @returns A fresh time tag. Never {@link OSC_TIME_TAG_IMMEDIATELY}, except for
+ *   the one instant 2^-32 s after the 2036 rollover, which the two share.
+ * @throws {RangeError} When `date` is invalid or outside the range above.
+ */
+export declare function oscTimeTagFromDate(date: Date | number): OscTimeTag;
+//# sourceMappingURL=osc-time-tag-from-date.d.ts.map

package/dist/time-tag/osc-time-tag-from-date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"osc-time-tag-from-date.d.ts","sourceRoot":"","sources":["../../src/time-tag/osc-time-tag-from-date.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,UAAU,CA0BlE"}

package/dist/time-tag/osc-time-tag-from-date.js

@@ -0,0 +1,48 @@
+import { NTP_UNIX_OFFSET_SECONDS_, TWO_POW_31_, TWO_POW_32_ } from "./_ntp.js";
+/**
+ * Converts an instant to the OSC time tag naming it.
+ *
+ * The 32-bit `seconds` field wraps every 2^32 s (about 136 years), so a tag is
+ * read with the RFC 4330 §3 rule: a value with its most significant bit set is
+ * in NTP era 0 (from 1900), one with it clear is in era 1 (from
+ * 2036-02-07T06:28:16Z). The instants that rule can name, and so the ones this
+ * accepts, run from 1968-01-20T03:14:08Z inclusive to 2104-02-26T09:42:24Z
+ * exclusive.
+ *
+ * The fraction is rounded to the nearest 2^-32 s, so a whole number of
+ * milliseconds survives {@link oscTimeTagToDate} exactly. A fractional `number`
+ * keeps its sub-millisecond part as far as `number` resolves it.
+ *
+ * @example
+ * 	```ts
+ * 	oscTimeTagFromDate(0); // { seconds: 2208988800, fraction: 0 }
+ * 	oscTimeTagFromDate(new Date("2036-02-07T06:28:16.500Z")); // { seconds: 0, fraction: 2147483648 }
+ * 	```;
+ *
+ * @param date - The instant, as a `Date` or as milliseconds since the Unix
+ *   epoch (`Date.now()`, `performance.timeOrigin + performance.now()`).
+ * @returns A fresh time tag. Never {@link OSC_TIME_TAG_IMMEDIATELY}, except for
+ *   the one instant 2^-32 s after the 2036 rollover, which the two share.
+ * @throws {RangeError} When `date` is invalid or outside the range above.
+ */
+export function oscTimeTagFromDate(date) {
+    const milliseconds = typeof date === "number" ? date : date.getTime();
+    if (!Number.isFinite(milliseconds)) {
+        throw new RangeError(`oscTimeTagFromDate: invalid date ${String(date)}`);
+    }
+    let unixSeconds = Math.floor(milliseconds / 1000);
+    let fraction = Math.round(((milliseconds - unixSeconds * 1000) * TWO_POW_32_) / 1000);
+    if (fraction === TWO_POW_32_) {
+        fraction = 0;
+        unixSeconds += 1;
+    }
+    const ntpSeconds = unixSeconds + NTP_UNIX_OFFSET_SECONDS_;
+    if (ntpSeconds < TWO_POW_31_ || ntpSeconds >= TWO_POW_32_ + TWO_POW_31_) {
+        throw new RangeError(`oscTimeTagFromDate: ${new Date(milliseconds).toISOString()} is outside the range an NTP time tag names (1968-01-20T03:14:08Z to 2104-02-26T09:42:24Z)`);
+    }
+    return {
+        seconds: ntpSeconds >= TWO_POW_32_ ? ntpSeconds - TWO_POW_32_ : ntpSeconds,
+        fraction,
+    };
+}
+//# sourceMappingURL=osc-time-tag-from-date.js.map

package/dist/time-tag/osc-time-tag-from-date.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"osc-time-tag-from-date.js","sourceRoot":"","sources":["../../src/time-tag/osc-time-tag-from-date.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG/E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAmB;IACrD,MAAM,YAAY,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IACtE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,UAAU,CAAC,oCAAoC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED,IAAI,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAClD,IAAI,QAAQ,GAAG,IAAI,CAAC,KAAK,CACxB,CAAC,CAAC,YAAY,GAAG,WAAW,GAAG,IAAI,CAAC,GAAG,WAAW,CAAC,GAAG,IAAI,CAC1D,CAAC;IACF,IAAI,QAAQ,KAAK,WAAW,EAAE,CAAC;QAC9B,QAAQ,GAAG,CAAC,CAAC;QACb,WAAW,IAAI,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,UAAU,GAAG,WAAW,GAAG,wBAAwB,CAAC;IAC1D,IAAI,UAAU,GAAG,WAAW,IAAI,UAAU,IAAI,WAAW,GAAG,WAAW,EAAE,CAAC;QACzE,MAAM,IAAI,UAAU,CACnB,uBAAuB,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,WAAW,EAAE,4FAA4F,CACvJ,CAAC;IACH,CAAC;IAED,OAAO;QACN,OAAO,EAAE,UAAU,IAAI,WAAW,CAAC,CAAC,CAAC,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,UAAU;QAC1E,QAAQ;KACR,CAAC;AACH,CAAC"}

package/dist/time-tag/osc-time-tag-to-date.d.ts

@@ -0,0 +1,21 @@
+import type { OscTimeTag } from "./osc-time-tag.js";
+/**
+ * Converts an OSC time tag to the instant it names.
+ *
+ * `seconds` is read with the RFC 4330 §3 era rule {@link oscTimeTagFromDate}
+ * documents, so every tag maps to an instant between 1968-01-20T03:14:08Z and
+ * 2104-02-26T09:42:24Z. {@link OSC_TIME_TAG_IMMEDIATELY} is not an instant:
+ * test for it with {@link isOscTimeTagImmediately} first.
+ *
+ * A `Date` holds whole milliseconds, so the fraction is rounded to the nearest
+ * millisecond (a half rounds up), at most 0.5 ms from the tag.
+ *
+ * @example
+ * 	```ts
+ * 	oscTimeTagToDate({ seconds: 2208988800, fraction: 0 }).toISOString(); // "1970-01-01T00:00:00.000Z"
+ * 	```;
+ *
+ * @throws {RangeError} When a field of `tag` is not an unsigned 32-bit integer.
+ */
+export declare function oscTimeTagToDate(tag: OscTimeTag): Date;
+//# sourceMappingURL=osc-time-tag-to-date.d.ts.map

package/dist/time-tag/osc-time-tag-to-date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"osc-time-tag-to-date.d.ts","sourceRoot":"","sources":["../../src/time-tag/osc-time-tag-to-date.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAUtD"}

package/dist/time-tag/osc-time-tag-to-date.js

@@ -0,0 +1,26 @@
+import { assertOscTimeTag_, NTP_UNIX_OFFSET_SECONDS_, TWO_POW_31_, TWO_POW_32_, } from "./_ntp.js";
+/**
+ * Converts an OSC time tag to the instant it names.
+ *
+ * `seconds` is read with the RFC 4330 §3 era rule {@link oscTimeTagFromDate}
+ * documents, so every tag maps to an instant between 1968-01-20T03:14:08Z and
+ * 2104-02-26T09:42:24Z. {@link OSC_TIME_TAG_IMMEDIATELY} is not an instant:
+ * test for it with {@link isOscTimeTagImmediately} first.
+ *
+ * A `Date` holds whole milliseconds, so the fraction is rounded to the nearest
+ * millisecond (a half rounds up), at most 0.5 ms from the tag.
+ *
+ * @example
+ * 	```ts
+ * 	oscTimeTagToDate({ seconds: 2208988800, fraction: 0 }).toISOString(); // "1970-01-01T00:00:00.000Z"
+ * 	```;
+ *
+ * @throws {RangeError} When a field of `tag` is not an unsigned 32-bit integer.
+ */
+export function oscTimeTagToDate(tag) {
+    assertOscTimeTag_(tag, "oscTimeTagToDate");
+    const ntpSeconds = tag.seconds >= TWO_POW_31_ ? tag.seconds : tag.seconds + TWO_POW_32_;
+    return new Date((ntpSeconds - NTP_UNIX_OFFSET_SECONDS_) * 1000 +
+        Math.round((tag.fraction * 1000) / TWO_POW_32_));
+}
+//# sourceMappingURL=osc-time-tag-to-date.js.map

package/dist/time-tag/osc-time-tag-to-date.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"osc-time-tag-to-date.js","sourceRoot":"","sources":["../../src/time-tag/osc-time-tag-to-date.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,iBAAiB,EACjB,wBAAwB,EACxB,WAAW,EACX,WAAW,GACX,MAAM,WAAW,CAAC;AAGnB;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAe;IAC/C,iBAAiB,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;IAE3C,MAAM,UAAU,GACf,GAAG,CAAC,OAAO,IAAI,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,GAAG,WAAW,CAAC;IAEtE,OAAO,IAAI,IAAI,CACd,CAAC,UAAU,GAAG,wBAAwB,CAAC,GAAG,IAAI;QAC7C,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,WAAW,CAAC,CAChD,CAAC;AACH,CAAC"}