ab0fa6909bb69bf38143d8e1fc37198127dbd57e5bd53c9620b1407c3cd1610f

workers1/auto3d/node_modules/capnp-ts/src/serialization/list-element-size.ts

@@ -0,0 +1,25 @@
+/**
+ * @author jdiaz5513
+ */
+
+export enum ListElementSize {
+  VOID = 0,
+  BIT = 1,
+  BYTE = 2,
+  BYTE_2 = 3,
+  BYTE_4 = 4,
+  BYTE_8 = 5,
+  POINTER = 6,
+  COMPOSITE = 7
+}
+
+export const ListElementOffset = [
+  0, // void
+  0.125, // bit
+  1, // byte
+  2, // two byte
+  4, // four byte
+  8, // eight byte
+  8, // pointer
+  NaN // composite
+];

workers1/auto3d/node_modules/capnp-ts/src/serialization/mask.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @author jdiaz5513
+ */
+import { Int64, Uint64 } from "../types/index";
+export declare const getFloat32Mask: (x: number) => DataView;
+export declare const getFloat64Mask: (x: number) => DataView;
+export declare const getInt16Mask: (x: number) => DataView;
+export declare const getInt32Mask: (x: number) => DataView;
+export declare const getInt8Mask: (x: number) => DataView;
+export declare const getUint16Mask: (x: number) => DataView;
+export declare const getUint32Mask: (x: number) => DataView;
+export declare const getUint8Mask: (x: number) => DataView;
+export declare function getBitMask(value: boolean, bitOffset: number): DataView;
+export declare function getInt64Mask(x: Int64): DataView;
+export declare function getUint64Mask(x: Uint64): DataView;
+export declare function getVoidMask(): void;

workers1/auto3d/node_modules/capnp-ts/src/serialization/mask.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVoidMask = exports.getUint64Mask = exports.getInt64Mask = exports.getBitMask = exports.getUint8Mask = exports.getUint32Mask = exports.getUint16Mask = exports.getInt8Mask = exports.getInt32Mask = exports.getInt16Mask = exports.getFloat64Mask = exports.getFloat32Mask = void 0;
+const errors_1 = require("../errors");
+function _makePrimitiveMaskFn(byteLength, setter) {
+    return (x) => {
+        const dv = new DataView(new ArrayBuffer(byteLength));
+        setter.call(dv, 0, x, true);
+        return dv;
+    };
+}
+/* eslint-disable @typescript-eslint/unbound-method */
+exports.getFloat32Mask = _makePrimitiveMaskFn(4, DataView.prototype.setFloat32);
+exports.getFloat64Mask = _makePrimitiveMaskFn(8, DataView.prototype.setFloat64);
+exports.getInt16Mask = _makePrimitiveMaskFn(2, DataView.prototype.setInt16);
+exports.getInt32Mask = _makePrimitiveMaskFn(4, DataView.prototype.setInt32);
+exports.getInt8Mask = _makePrimitiveMaskFn(1, DataView.prototype.setInt8);
+exports.getUint16Mask = _makePrimitiveMaskFn(2, DataView.prototype.setUint16);
+exports.getUint32Mask = _makePrimitiveMaskFn(4, DataView.prototype.setUint32);
+exports.getUint8Mask = _makePrimitiveMaskFn(1, DataView.prototype.setUint8);
+/* eslint-enable */
+function getBitMask(value, bitOffset) {
+    const dv = new DataView(new ArrayBuffer(1));
+    if (!value)
+        return dv;
+    dv.setUint8(0, 1 << bitOffset % 8);
+    return dv;
+}
+exports.getBitMask = getBitMask;
+function getInt64Mask(x) {
+    return x.toDataView();
+}
+exports.getInt64Mask = getInt64Mask;
+function getUint64Mask(x) {
+    return x.toDataView();
+}
+exports.getUint64Mask = getUint64Mask;
+function getVoidMask() {
+    throw new Error(errors_1.INVARIANT_UNREACHABLE_CODE);
+}
+exports.getVoidMask = getVoidMask;
+//# sourceMappingURL=mask.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/mask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask.js","sourceRoot":"","sources":["mask.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,sCAAuD;AAKvD,SAAS,oBAAoB,CAAC,UAAkB,EAAE,MAAsB;IACtE,OAAO,CAAC,CAAS,EAAY,EAAE;QAC7B,MAAM,EAAE,GAAG,IAAI,QAAQ,CAAC,IAAI,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;QACrD,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QAC5B,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;AACJ,CAAC;AAED,sDAAsD;AACzC,QAAA,cAAc,GAAG,oBAAoB,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;AACxE,QAAA,cAAc,GAAG,oBAAoB,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;AACxE,QAAA,YAAY,GAAG,oBAAoB,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AACpE,QAAA,YAAY,GAAG,oBAAoB,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AACpE,QAAA,WAAW,GAAG,oBAAoB,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAClE,QAAA,aAAa,GAAG,oBAAoB,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AACtE,QAAA,aAAa,GAAG,oBAAoB,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AACtE,QAAA,YAAY,GAAG,oBAAoB,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AACjF,mBAAmB;AAEnB,SAAgB,UAAU,CAAC,KAAc,EAAE,SAAiB;IAC1D,MAAM,EAAE,GAAG,IAAI,QAAQ,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAE5C,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IAEtB,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC;IACnC,OAAO,EAAE,CAAC;AACZ,CAAC;AAPD,gCAOC;AAED,SAAgB,YAAY,CAAC,CAAQ;IACnC,OAAO,CAAC,CAAC,UAAU,EAAE,CAAC;AACxB,CAAC;AAFD,oCAEC;AAED,SAAgB,aAAa,CAAC,CAAS;IACrC,OAAO,CAAC,CAAC,UAAU,EAAE,CAAC;AACxB,CAAC;AAFD,sCAEC;AAED,SAAgB,WAAW;IACzB,MAAM,IAAI,KAAK,CAAC,mCAA0B,CAAC,CAAC;AAC9C,CAAC;AAFD,kCAEC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/mask.ts

@@ -0,0 +1,48 @@
+/**
+ * @author jdiaz5513
+ */
+
+import { INVARIANT_UNREACHABLE_CODE } from "../errors";
+import { Int64, Uint64 } from "../types/index";
+
+type DataViewSetter = (byteOffset: number, value: number, littleEndian?: boolean) => void;
+
+function _makePrimitiveMaskFn(byteLength: number, setter: DataViewSetter): (x: number) => DataView {
+  return (x: number): DataView => {
+    const dv = new DataView(new ArrayBuffer(byteLength));
+    setter.call(dv, 0, x, true);
+    return dv;
+  };
+}
+
+/* eslint-disable @typescript-eslint/unbound-method */
+export const getFloat32Mask = _makePrimitiveMaskFn(4, DataView.prototype.setFloat32);
+export const getFloat64Mask = _makePrimitiveMaskFn(8, DataView.prototype.setFloat64);
+export const getInt16Mask = _makePrimitiveMaskFn(2, DataView.prototype.setInt16);
+export const getInt32Mask = _makePrimitiveMaskFn(4, DataView.prototype.setInt32);
+export const getInt8Mask = _makePrimitiveMaskFn(1, DataView.prototype.setInt8);
+export const getUint16Mask = _makePrimitiveMaskFn(2, DataView.prototype.setUint16);
+export const getUint32Mask = _makePrimitiveMaskFn(4, DataView.prototype.setUint32);
+export const getUint8Mask = _makePrimitiveMaskFn(1, DataView.prototype.setUint8);
+/* eslint-enable */
+
+export function getBitMask(value: boolean, bitOffset: number): DataView {
+  const dv = new DataView(new ArrayBuffer(1));
+
+  if (!value) return dv;
+
+  dv.setUint8(0, 1 << bitOffset % 8);
+  return dv;
+}
+
+export function getInt64Mask(x: Int64): DataView {
+  return x.toDataView();
+}
+
+export function getUint64Mask(x: Uint64): DataView {
+  return x.toDataView();
+}
+
+export function getVoidMask(): void {
+  throw new Error(INVARIANT_UNREACHABLE_CODE);
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/message.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @author jdiaz5513
+ */
+import { AnyArena } from "./arena";
+import { Pointer, StructCtor, Struct } from "./pointers";
+import { Segment } from "./segment";
+export interface _Message {
+    readonly arena: AnyArena;
+    segments: Segment[];
+    traversalLimit: number;
+}
+export declare class Message {
+    static readonly allocateSegment: typeof allocateSegment;
+    static readonly dump: typeof dump;
+    static readonly getRoot: typeof getRoot;
+    static readonly getSegment: typeof getSegment;
+    static readonly initRoot: typeof initRoot;
+    static readonly readRawPointer: typeof readRawPointer;
+    static readonly toArrayBuffer: typeof toArrayBuffer;
+    static readonly toPackedArrayBuffer: typeof toPackedArrayBuffer;
+    readonly _capnp: _Message;
+    /**
+     * A Cap'n Proto message.
+     *
+     * SECURITY WARNING: In nodejs do not pass a Buffer's internal array buffer into this constructor. Pass the buffer
+     * directly and everything will be fine. If not, your message will potentially be initialized with random memory
+     * contents!
+     *
+     * The constructor method creates a new Message, optionally using a provided arena for segment allocation, or a buffer
+     * to read from.
+     *
+     * @constructor {Message}
+     *
+     * @param {AnyArena|ArrayBufferView|ArrayBuffer} [src] The source for the message.
+     * A value of `undefined` will cause the message to initialize with a single segment arena only big enough for the
+     * root pointer; it will expand as you go. This is a reasonable choice for most messages.
+     *
+     * Passing an arena will cause the message to use that arena for its segment allocation. Contents will be accepted
+     * as-is.
+     *
+     * Passing an array buffer view (like `DataView`, `Uint8Array` or `Buffer`) will create a **copy** of the source
+     * buffer; beware of the potential performance cost!
+     *
+     * @param {boolean} [packed] Whether or not the message is packed. If `true` (the default), the message will be
+     * unpacked.
+     *
+     * @param {boolean} [singleSegment] If true, `src` will be treated as a message consisting of a single segment without
+     * a framing header.
+     *
+     */
+    constructor(src?: AnyArena | ArrayBufferView | ArrayBuffer, packed?: boolean, singleSegment?: boolean);
+    allocateSegment(byteLength: number): Segment;
+    /**
+     * Create a pretty-printed string dump of this message; incredibly useful for debugging.
+     *
+     * WARNING: Do not call this method on large messages!
+     *
+     * @returns {string} A big steaming pile of pretty hex digits.
+     */
+    dump(): string;
+    /**
+     * Get a struct pointer for the root of this message. This is primarily used when reading a message; it will not
+     * overwrite existing data.
+     *
+     * @template T
+     * @param {StructCtor<T>} RootStruct The struct type to use as the root.
+     * @returns {T} A struct representing the root of the message.
+     */
+    getRoot<T extends Struct>(RootStruct: StructCtor<T>): T;
+    /**
+     * Get a segment by its id.
+     *
+     * This will lazily allocate the first segment if it doesn't already exist.
+     *
+     * @param {number} id The segment id.
+     * @returns {Segment} The requested segment.
+     */
+    getSegment(id: number): Segment;
+    /**
+     * Initialize a new message using the provided struct type as the root.
+     *
+     * @template T
+     * @param {StructCtor<T>} RootStruct The struct type to use as the root.
+     * @returns {T} An initialized struct pointing to the root of the message.
+     */
+    initRoot<T extends Struct>(RootStruct: StructCtor<T>): T;
+    /**
+     * Set the root of the message to a copy of the given pointer. Used internally
+     * to make copies of pointers for default values.
+     *
+     * @param {Pointer} src The source pointer to copy.
+     * @returns {void}
+     */
+    setRoot(src: Pointer): void;
+    /**
+     * Combine the contents of this message's segments into a single array buffer and prepend a stream framing header
+     * containing information about the following segment data.
+     *
+     * @returns {ArrayBuffer} An ArrayBuffer with the contents of this message.
+     */
+    toArrayBuffer(): ArrayBuffer;
+    /**
+     * Like `toArrayBuffer()`, but also applies the packing algorithm to the output. This is typically what you want to
+     * use if you're sending the message over a network link or other slow I/O interface where size matters.
+     *
+     * @returns {ArrayBuffer} A packed message.
+     */
+    toPackedArrayBuffer(): ArrayBuffer;
+    toString(): string;
+}
+export interface CreateMessageOptions {
+    packed?: boolean;
+    singleSegment?: boolean;
+}
+export declare function initMessage(src?: AnyArena | ArrayBufferView | ArrayBuffer, packed?: boolean, singleSegment?: boolean): _Message;
+/**
+ * Given an _unpacked_ message with a segment framing header, this will generate an ArrayBuffer for each segment in
+ * the message.
+ *
+ * This method is not typically called directly, but can be useful in certain cases.
+ *
+ * @static
+ * @param {ArrayBuffer} message An unpacked message with a framing header.
+ * @returns {ArrayBuffer[]} An array of buffers containing the segment data.
+ */
+export declare function getFramedSegments(message: ArrayBuffer): ArrayBuffer[];
+/**
+ * This method is called on messages that were constructed with existing data to prepopulate the segments array with
+ * everything we can find in the arena. Each segment will have it's `byteLength` set to the size of its buffer.
+ *
+ * Technically speaking, the message's segments will be "full" after calling this function. Calling this on your own
+ * may void your warranty.
+ *
+ * @param {Message} m The message to allocate.
+ * @returns {void}
+ */
+export declare function preallocateSegments(m: Message): void;
+export declare function allocateSegment(byteLength: number, m: Message): Segment;
+export declare function dump(m: Message): string;
+export declare function getRoot<T extends Struct>(RootStruct: StructCtor<T>, m: Message): T;
+export declare function getSegment(id: number, m: Message): Segment;
+export declare function initRoot<T extends Struct>(RootStruct: StructCtor<T>, m: Message): T;
+/**
+ * Read a pointer in raw form (a packed message with framing headers). Does not
+ * care or attempt to validate the input beyond parsing the message
+ * segments.
+ *
+ * This is typically used by the compiler to load default values, but can be
+ * useful to work with messages with an unknown schema.
+ *
+ * @param {ArrayBuffer} data The raw data to read.
+ * @returns {Pointer} A root pointer.
+ */
+export declare function readRawPointer(data: ArrayBuffer): Pointer;
+export declare function setRoot(src: Pointer, m: Message): void;
+export declare function toArrayBuffer(m: Message): ArrayBuffer;
+export declare function toPackedArrayBuffer(m: Message): ArrayBuffer;
+export declare function getStreamFrame(m: Message): ArrayBuffer;

workers1/auto3d/node_modules/capnp-ts/src/serialization/message.js

@@ -0,0 +1,392 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStreamFrame = exports.toPackedArrayBuffer = exports.toArrayBuffer = exports.setRoot = exports.readRawPointer = exports.initRoot = exports.getSegment = exports.getRoot = exports.dump = exports.allocateSegment = exports.preallocateSegments = exports.getFramedSegments = exports.initMessage = exports.Message = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
+const util_1 = require("../util");
+const arena_1 = require("./arena");
+const packing_1 = require("./packing");
+const pointers_1 = require("./pointers");
+const segment_1 = require("./segment");
+const pointer_1 = require("./pointers/pointer");
+const struct_1 = require("./pointers/struct");
+const trace = debug_1.default("capnp:message");
+trace("load");
+class Message {
+    /**
+     * A Cap'n Proto message.
+     *
+     * SECURITY WARNING: In nodejs do not pass a Buffer's internal array buffer into this constructor. Pass the buffer
+     * directly and everything will be fine. If not, your message will potentially be initialized with random memory
+     * contents!
+     *
+     * The constructor method creates a new Message, optionally using a provided arena for segment allocation, or a buffer
+     * to read from.
+     *
+     * @constructor {Message}
+     *
+     * @param {AnyArena|ArrayBufferView|ArrayBuffer} [src] The source for the message.
+     * A value of `undefined` will cause the message to initialize with a single segment arena only big enough for the
+     * root pointer; it will expand as you go. This is a reasonable choice for most messages.
+     *
+     * Passing an arena will cause the message to use that arena for its segment allocation. Contents will be accepted
+     * as-is.
+     *
+     * Passing an array buffer view (like `DataView`, `Uint8Array` or `Buffer`) will create a **copy** of the source
+     * buffer; beware of the potential performance cost!
+     *
+     * @param {boolean} [packed] Whether or not the message is packed. If `true` (the default), the message will be
+     * unpacked.
+     *
+     * @param {boolean} [singleSegment] If true, `src` will be treated as a message consisting of a single segment without
+     * a framing header.
+     *
+     */
+    constructor(src, packed = true, singleSegment = false) {
+        this._capnp = initMessage(src, packed, singleSegment);
+        if (src && !isAnyArena(src))
+            preallocateSegments(this);
+        trace("new %s", this);
+    }
+    allocateSegment(byteLength) {
+        return allocateSegment(byteLength, this);
+    }
+    /**
+     * Create a pretty-printed string dump of this message; incredibly useful for debugging.
+     *
+     * WARNING: Do not call this method on large messages!
+     *
+     * @returns {string} A big steaming pile of pretty hex digits.
+     */
+    dump() {
+        return dump(this);
+    }
+    /**
+     * Get a struct pointer for the root of this message. This is primarily used when reading a message; it will not
+     * overwrite existing data.
+     *
+     * @template T
+     * @param {StructCtor<T>} RootStruct The struct type to use as the root.
+     * @returns {T} A struct representing the root of the message.
+     */
+    getRoot(RootStruct) {
+        return getRoot(RootStruct, this);
+    }
+    /**
+     * Get a segment by its id.
+     *
+     * This will lazily allocate the first segment if it doesn't already exist.
+     *
+     * @param {number} id The segment id.
+     * @returns {Segment} The requested segment.
+     */
+    getSegment(id) {
+        return getSegment(id, this);
+    }
+    /**
+     * Initialize a new message using the provided struct type as the root.
+     *
+     * @template T
+     * @param {StructCtor<T>} RootStruct The struct type to use as the root.
+     * @returns {T} An initialized struct pointing to the root of the message.
+     */
+    initRoot(RootStruct) {
+        return initRoot(RootStruct, this);
+    }
+    /**
+     * Set the root of the message to a copy of the given pointer. Used internally
+     * to make copies of pointers for default values.
+     *
+     * @param {Pointer} src The source pointer to copy.
+     * @returns {void}
+     */
+    setRoot(src) {
+        setRoot(src, this);
+    }
+    /**
+     * Combine the contents of this message's segments into a single array buffer and prepend a stream framing header
+     * containing information about the following segment data.
+     *
+     * @returns {ArrayBuffer} An ArrayBuffer with the contents of this message.
+     */
+    toArrayBuffer() {
+        return toArrayBuffer(this);
+    }
+    /**
+     * Like `toArrayBuffer()`, but also applies the packing algorithm to the output. This is typically what you want to
+     * use if you're sending the message over a network link or other slow I/O interface where size matters.
+     *
+     * @returns {ArrayBuffer} A packed message.
+     */
+    toPackedArrayBuffer() {
+        return toPackedArrayBuffer(this);
+    }
+    toString() {
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        return `Message_arena:${this._capnp.arena}`;
+    }
+}
+exports.Message = Message;
+Message.allocateSegment = allocateSegment;
+Message.dump = dump;
+Message.getRoot = getRoot;
+Message.getSegment = getSegment;
+Message.initRoot = initRoot;
+Message.readRawPointer = readRawPointer;
+Message.toArrayBuffer = toArrayBuffer;
+Message.toPackedArrayBuffer = toPackedArrayBuffer;
+function initMessage(src, packed = true, singleSegment = false) {
+    if (src === undefined) {
+        return {
+            arena: new arena_1.SingleSegmentArena(),
+            segments: [],
+            traversalLimit: constants_1.DEFAULT_TRAVERSE_LIMIT,
+        };
+    }
+    if (isAnyArena(src)) {
+        return { arena: src, segments: [], traversalLimit: constants_1.DEFAULT_TRAVERSE_LIMIT };
+    }
+    let buf = src;
+    if (isArrayBufferView(buf)) {
+        buf = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    }
+    if (packed)
+        buf = packing_1.unpack(buf);
+    if (singleSegment) {
+        return {
+            arena: new arena_1.SingleSegmentArena(buf),
+            segments: [],
+            traversalLimit: constants_1.DEFAULT_TRAVERSE_LIMIT,
+        };
+    }
+    return {
+        arena: new arena_1.MultiSegmentArena(getFramedSegments(buf)),
+        segments: [],
+        traversalLimit: constants_1.DEFAULT_TRAVERSE_LIMIT,
+    };
+}
+exports.initMessage = initMessage;
+/**
+ * Given an _unpacked_ message with a segment framing header, this will generate an ArrayBuffer for each segment in
+ * the message.
+ *
+ * This method is not typically called directly, but can be useful in certain cases.
+ *
+ * @static
+ * @param {ArrayBuffer} message An unpacked message with a framing header.
+ * @returns {ArrayBuffer[]} An array of buffers containing the segment data.
+ */
+function getFramedSegments(message) {
+    const dv = new DataView(message);
+    const segmentCount = dv.getUint32(0, true) + 1;
+    const segments = new Array(segmentCount);
+    trace("reading %d framed segments from stream", segmentCount);
+    let byteOffset = 4 + segmentCount * 4;
+    byteOffset += byteOffset % 8;
+    if (byteOffset + segmentCount * 4 > message.byteLength) {
+        throw new Error(errors_1.MSG_INVALID_FRAME_HEADER);
+    }
+    for (let i = 0; i < segmentCount; i++) {
+        const byteLength = dv.getUint32(4 + i * 4, true) * 8;
+        if (byteOffset + byteLength > message.byteLength) {
+            throw new Error(errors_1.MSG_INVALID_FRAME_HEADER);
+        }
+        segments[i] = message.slice(byteOffset, byteOffset + byteLength);
+        byteOffset += byteLength;
+    }
+    return segments;
+}
+exports.getFramedSegments = getFramedSegments;
+/**
+ * This method is called on messages that were constructed with existing data to prepopulate the segments array with
+ * everything we can find in the arena. Each segment will have it's `byteLength` set to the size of its buffer.
+ *
+ * Technically speaking, the message's segments will be "full" after calling this function. Calling this on your own
+ * may void your warranty.
+ *
+ * @param {Message} m The message to allocate.
+ * @returns {void}
+ */
+function preallocateSegments(m) {
+    const numSegments = arena_1.Arena.getNumSegments(m._capnp.arena);
+    if (numSegments < 1)
+        throw new Error(errors_1.MSG_NO_SEGMENTS_IN_ARENA);
+    m._capnp.segments = new Array(numSegments);
+    for (let i = 0; i < numSegments; i++) {
+        // Set up each segment so that they're fully allocated to the extents of the existing buffers.
+        const buffer = arena_1.Arena.getBuffer(i, m._capnp.arena);
+        const segment = new segment_1.Segment(i, m, buffer, buffer.byteLength);
+        m._capnp.segments[i] = segment;
+    }
+}
+exports.preallocateSegments = preallocateSegments;
+function isArrayBufferView(src) {
+    return src.byteOffset !== undefined;
+}
+function isAnyArena(o) {
+    return o.kind !== undefined;
+}
+function allocateSegment(byteLength, m) {
+    trace("allocating %x bytes for %s", byteLength, m);
+    const res = arena_1.Arena.allocate(byteLength, m._capnp.segments, m._capnp.arena);
+    let s;
+    if (res.id === m._capnp.segments.length) {
+        // Note how we're only allowing new segments in if they're exactly the next one in the array. There is no logical
+        // reason for segments to be created out of order.
+        s = new segment_1.Segment(res.id, m, res.buffer);
+        trace("adding new segment %s", s);
+        m._capnp.segments.push(s);
+    }
+    else if (res.id < 0 || res.id > m._capnp.segments.length) {
+        throw new Error(util_1.format(errors_1.MSG_SEGMENT_OUT_OF_BOUNDS, res.id, m));
+    }
+    else {
+        s = m._capnp.segments[res.id];
+        trace("replacing segment %s with buffer (len:%d)", s, res.buffer.byteLength);
+        s.replaceBuffer(res.buffer);
+    }
+    return s;
+}
+exports.allocateSegment = allocateSegment;
+function dump(m) {
+    let r = "";
+    if (m._capnp.segments.length === 0) {
+        return "================\nNo Segments\n================\n";
+    }
+    for (let i = 0; i < m._capnp.segments.length; i++) {
+        r += `================\nSegment #${i}\n================\n`;
+        const { buffer, byteLength } = m._capnp.segments[i];
+        const b = new Uint8Array(buffer, 0, byteLength);
+        r += util_1.dumpBuffer(b);
+    }
+    return r;
+}
+exports.dump = dump;
+function getRoot(RootStruct, m) {
+    const root = new RootStruct(m.getSegment(0), 0);
+    pointer_1.validate(pointers_1.PointerType.STRUCT, root);
+    const ts = pointer_1.getTargetStructSize(root);
+    // Make sure the underlying pointer is actually big enough to hold the data and pointers as specified in the schema.
+    // If not a shallow copy of the struct contents needs to be made before returning.
+    if (ts.dataByteLength < RootStruct._capnp.size.dataByteLength ||
+        ts.pointerLength < RootStruct._capnp.size.pointerLength) {
+        trace("need to resize root struct %s", root);
+        struct_1.resize(RootStruct._capnp.size, root);
+    }
+    return root;
+}
+exports.getRoot = getRoot;
+function getSegment(id, m) {
+    const segmentLength = m._capnp.segments.length;
+    if (id === 0 && segmentLength === 0) {
+        // Segment zero is special. If we have no segments in the arena we'll want to allocate a new one and leave room
+        // for the root pointer.
+        const arenaSegments = arena_1.Arena.getNumSegments(m._capnp.arena);
+        if (arenaSegments === 0) {
+            allocateSegment(constants_1.DEFAULT_BUFFER_SIZE, m);
+        }
+        else {
+            // Okay, the arena already has a buffer we can use. This is totally fine.
+            m._capnp.segments[0] = new segment_1.Segment(0, m, arena_1.Arena.getBuffer(0, m._capnp.arena));
+        }
+        if (!m._capnp.segments[0].hasCapacity(8)) {
+            throw new Error(errors_1.MSG_SEGMENT_TOO_SMALL);
+        }
+        // This will leave room for the root pointer.
+        m._capnp.segments[0].allocate(8);
+        return m._capnp.segments[0];
+    }
+    if (id < 0 || id >= segmentLength) {
+        throw new Error(util_1.format(errors_1.MSG_SEGMENT_OUT_OF_BOUNDS, id, m));
+    }
+    return m._capnp.segments[id];
+}
+exports.getSegment = getSegment;
+function initRoot(RootStruct, m) {
+    const root = new RootStruct(m.getSegment(0), 0);
+    struct_1.initStruct(RootStruct._capnp.size, root);
+    trace("Initialized root pointer %s for %s.", root, m);
+    return root;
+}
+exports.initRoot = initRoot;
+/**
+ * Read a pointer in raw form (a packed message with framing headers). Does not
+ * care or attempt to validate the input beyond parsing the message
+ * segments.
+ *
+ * This is typically used by the compiler to load default values, but can be
+ * useful to work with messages with an unknown schema.
+ *
+ * @param {ArrayBuffer} data The raw data to read.
+ * @returns {Pointer} A root pointer.
+ */
+function readRawPointer(data) {
+    return new pointers_1.Pointer(new Message(data).getSegment(0), 0);
+}
+exports.readRawPointer = readRawPointer;
+function setRoot(src, m) {
+    pointers_1.Pointer.copyFrom(src, new pointers_1.Pointer(m.getSegment(0), 0));
+}
+exports.setRoot = setRoot;
+function toArrayBuffer(m) {
+    const streamFrame = getStreamFrame(m);
+    // Make sure the first segment is allocated.
+    if (m._capnp.segments.length === 0)
+        getSegment(0, m);
+    const segments = m._capnp.segments;
+    // Add space for the stream framing.
+    const totalLength = streamFrame.byteLength + segments.reduce((l, s) => l + util_1.padToWord(s.byteLength), 0);
+    const out = new Uint8Array(new ArrayBuffer(totalLength));
+    let o = streamFrame.byteLength;
+    out.set(new Uint8Array(streamFrame));
+    segments.forEach((s) => {
+        const segmentLength = util_1.padToWord(s.byteLength);
+        out.set(new Uint8Array(s.buffer, 0, segmentLength), o);
+        o += segmentLength;
+    });
+    return out.buffer;
+}
+exports.toArrayBuffer = toArrayBuffer;
+function toPackedArrayBuffer(m) {
+    const streamFrame = packing_1.pack(getStreamFrame(m));
+    // Make sure the first segment is allocated.
+    if (m._capnp.segments.length === 0)
+        m.getSegment(0);
+    // NOTE: A copy operation can be avoided here if we capture the intermediate array and use that directly in the copy
+    // loop below, rather than have `pack()` copy it to an ArrayBuffer just to have to copy it again later. If the
+    // intermediate array can be avoided altogether that's even better!
+    const segments = m._capnp.segments.map((s) => packing_1.pack(s.buffer, 0, util_1.padToWord(s.byteLength)));
+    const totalLength = streamFrame.byteLength + segments.reduce((l, s) => l + s.byteLength, 0);
+    const out = new Uint8Array(new ArrayBuffer(totalLength));
+    let o = streamFrame.byteLength;
+    out.set(new Uint8Array(streamFrame));
+    segments.forEach((s) => {
+        out.set(new Uint8Array(s), o);
+        o += s.byteLength;
+    });
+    return out.buffer;
+}
+exports.toPackedArrayBuffer = toPackedArrayBuffer;
+function getStreamFrame(m) {
+    const length = m._capnp.segments.length;
+    if (length === 0) {
+        // Don't bother allocating the first segment, just return a single zero word for the frame header.
+        return new Float64Array(1).buffer;
+    }
+    const frameLength = 4 + length * 4 + (1 - (length % 2)) * 4;
+    const out = new DataView(new ArrayBuffer(frameLength));
+    trace("Writing message stream frame with segment count: %d.", length);
+    out.setUint32(0, length - 1, true);
+    m._capnp.segments.forEach((s, i) => {
+        trace("Message segment %d word count: %d.", s.id, s.byteLength / 8);
+        out.setUint32(i * 4 + 4, s.byteLength / 8, true);
+    });
+    return out.buffer;
+}
+exports.getStreamFrame = getStreamFrame;
+//# sourceMappingURL=message.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/message.js.map

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

workers1/auto3d/node_modules/capnp-ts/src/serialization/message.ts

@@ -0,0 +1,507 @@
+/**
+ * @author jdiaz5513
+ */
+
+import initTrace from "debug";
+import { DEFAULT_TRAVERSE_LIMIT, DEFAULT_BUFFER_SIZE } from "../constants";
+import {
+  MSG_INVALID_FRAME_HEADER,
+  MSG_SEGMENT_OUT_OF_BOUNDS,
+  MSG_SEGMENT_TOO_SMALL,
+  MSG_NO_SEGMENTS_IN_ARENA,
+} from "../errors";
+import { dumpBuffer, format, padToWord } from "../util";
+import { AnyArena, Arena, MultiSegmentArena, SingleSegmentArena, ArenaKind } from "./arena";
+import { pack, unpack } from "./packing";
+import { Pointer, StructCtor, PointerType, Struct } from "./pointers";
+import { Segment } from "./segment";
+import { getTargetStructSize, validate } from "./pointers/pointer";
+import { resize, initStruct } from "./pointers/struct";
+
+const trace = initTrace("capnp:message");
+trace("load");
+
+export interface _Message {
+  readonly arena: AnyArena;
+  segments: Segment[];
+  traversalLimit: number;
+}
+
+export class Message {
+  static readonly allocateSegment = allocateSegment;
+  static readonly dump = dump;
+  static readonly getRoot = getRoot;
+  static readonly getSegment = getSegment;
+  static readonly initRoot = initRoot;
+  static readonly readRawPointer = readRawPointer;
+  static readonly toArrayBuffer = toArrayBuffer;
+  static readonly toPackedArrayBuffer = toPackedArrayBuffer;
+
+  readonly _capnp: _Message;
+
+  /**
+   * A Cap'n Proto message.
+   *
+   * SECURITY WARNING: In nodejs do not pass a Buffer's internal array buffer into this constructor. Pass the buffer
+   * directly and everything will be fine. If not, your message will potentially be initialized with random memory
+   * contents!
+   *
+   * The constructor method creates a new Message, optionally using a provided arena for segment allocation, or a buffer
+   * to read from.
+   *
+   * @constructor {Message}
+   *
+   * @param {AnyArena|ArrayBufferView|ArrayBuffer} [src] The source for the message.
+   * A value of `undefined` will cause the message to initialize with a single segment arena only big enough for the
+   * root pointer; it will expand as you go. This is a reasonable choice for most messages.
+   *
+   * Passing an arena will cause the message to use that arena for its segment allocation. Contents will be accepted
+   * as-is.
+   *
+   * Passing an array buffer view (like `DataView`, `Uint8Array` or `Buffer`) will create a **copy** of the source
+   * buffer; beware of the potential performance cost!
+   *
+   * @param {boolean} [packed] Whether or not the message is packed. If `true` (the default), the message will be
+   * unpacked.
+   *
+   * @param {boolean} [singleSegment] If true, `src` will be treated as a message consisting of a single segment without
+   * a framing header.
+   *
+   */
+  constructor(src?: AnyArena | ArrayBufferView | ArrayBuffer, packed = true, singleSegment = false) {
+    this._capnp = initMessage(src, packed, singleSegment);
+
+    if (src && !isAnyArena(src)) preallocateSegments(this);
+
+    trace("new %s", this);
+  }
+
+  allocateSegment(byteLength: number): Segment {
+    return allocateSegment(byteLength, this);
+  }
+
+  /**
+   * Create a pretty-printed string dump of this message; incredibly useful for debugging.
+   *
+   * WARNING: Do not call this method on large messages!
+   *
+   * @returns {string} A big steaming pile of pretty hex digits.
+   */
+
+  dump(): string {
+    return dump(this);
+  }
+
+  /**
+   * Get a struct pointer for the root of this message. This is primarily used when reading a message; it will not
+   * overwrite existing data.
+   *
+   * @template T
+   * @param {StructCtor<T>} RootStruct The struct type to use as the root.
+   * @returns {T} A struct representing the root of the message.
+   */
+
+  getRoot<T extends Struct>(RootStruct: StructCtor<T>): T {
+    return getRoot(RootStruct, this);
+  }
+
+  /**
+   * Get a segment by its id.
+   *
+   * This will lazily allocate the first segment if it doesn't already exist.
+   *
+   * @param {number} id The segment id.
+   * @returns {Segment} The requested segment.
+   */
+
+  getSegment(id: number): Segment {
+    return getSegment(id, this);
+  }
+
+  /**
+   * Initialize a new message using the provided struct type as the root.
+   *
+   * @template T
+   * @param {StructCtor<T>} RootStruct The struct type to use as the root.
+   * @returns {T} An initialized struct pointing to the root of the message.
+   */
+
+  initRoot<T extends Struct>(RootStruct: StructCtor<T>): T {
+    return initRoot(RootStruct, this);
+  }
+
+  /**
+   * Set the root of the message to a copy of the given pointer. Used internally
+   * to make copies of pointers for default values.
+   *
+   * @param {Pointer} src The source pointer to copy.
+   * @returns {void}
+   */
+
+  setRoot(src: Pointer): void {
+    setRoot(src, this);
+  }
+
+  /**
+   * Combine the contents of this message's segments into a single array buffer and prepend a stream framing header
+   * containing information about the following segment data.
+   *
+   * @returns {ArrayBuffer} An ArrayBuffer with the contents of this message.
+   */
+
+  toArrayBuffer(): ArrayBuffer {
+    return toArrayBuffer(this);
+  }
+
+  /**
+   * Like `toArrayBuffer()`, but also applies the packing algorithm to the output. This is typically what you want to
+   * use if you're sending the message over a network link or other slow I/O interface where size matters.
+   *
+   * @returns {ArrayBuffer} A packed message.
+   */
+
+  toPackedArrayBuffer(): ArrayBuffer {
+    return toPackedArrayBuffer(this);
+  }
+
+  toString(): string {
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    return `Message_arena:${this._capnp.arena}`;
+  }
+}
+
+export interface CreateMessageOptions {
+  packed?: boolean;
+  singleSegment?: boolean;
+}
+
+export function initMessage(
+  src?: AnyArena | ArrayBufferView | ArrayBuffer,
+  packed = true,
+  singleSegment = false
+): _Message {
+  if (src === undefined) {
+    return {
+      arena: new SingleSegmentArena(),
+      segments: [],
+      traversalLimit: DEFAULT_TRAVERSE_LIMIT,
+    };
+  }
+
+  if (isAnyArena(src)) {
+    return { arena: src, segments: [], traversalLimit: DEFAULT_TRAVERSE_LIMIT };
+  }
+
+  let buf: ArrayBuffer = src as ArrayBuffer;
+
+  if (isArrayBufferView(buf)) {
+    buf = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+
+  if (packed) buf = unpack(buf);
+
+  if (singleSegment) {
+    return {
+      arena: new SingleSegmentArena(buf),
+      segments: [],
+      traversalLimit: DEFAULT_TRAVERSE_LIMIT,
+    };
+  }
+
+  return {
+    arena: new MultiSegmentArena(getFramedSegments(buf)),
+    segments: [],
+    traversalLimit: DEFAULT_TRAVERSE_LIMIT,
+  };
+}
+
+/**
+ * Given an _unpacked_ message with a segment framing header, this will generate an ArrayBuffer for each segment in
+ * the message.
+ *
+ * This method is not typically called directly, but can be useful in certain cases.
+ *
+ * @static
+ * @param {ArrayBuffer} message An unpacked message with a framing header.
+ * @returns {ArrayBuffer[]} An array of buffers containing the segment data.
+ */
+
+export function getFramedSegments(message: ArrayBuffer): ArrayBuffer[] {
+  const dv = new DataView(message);
+
+  const segmentCount = dv.getUint32(0, true) + 1;
+
+  const segments = new Array(segmentCount) as ArrayBuffer[];
+
+  trace("reading %d framed segments from stream", segmentCount);
+
+  let byteOffset = 4 + segmentCount * 4;
+  byteOffset += byteOffset % 8;
+
+  if (byteOffset + segmentCount * 4 > message.byteLength) {
+    throw new Error(MSG_INVALID_FRAME_HEADER);
+  }
+
+  for (let i = 0; i < segmentCount; i++) {
+    const byteLength = dv.getUint32(4 + i * 4, true) * 8;
+
+    if (byteOffset + byteLength > message.byteLength) {
+      throw new Error(MSG_INVALID_FRAME_HEADER);
+    }
+
+    segments[i] = message.slice(byteOffset, byteOffset + byteLength);
+
+    byteOffset += byteLength;
+  }
+
+  return segments;
+}
+
+/**
+ * This method is called on messages that were constructed with existing data to prepopulate the segments array with
+ * everything we can find in the arena. Each segment will have it's `byteLength` set to the size of its buffer.
+ *
+ * Technically speaking, the message's segments will be "full" after calling this function. Calling this on your own
+ * may void your warranty.
+ *
+ * @param {Message} m The message to allocate.
+ * @returns {void}
+ */
+
+export function preallocateSegments(m: Message): void {
+  const numSegments = Arena.getNumSegments(m._capnp.arena);
+
+  if (numSegments < 1) throw new Error(MSG_NO_SEGMENTS_IN_ARENA);
+
+  m._capnp.segments = new Array(numSegments) as Segment[];
+
+  for (let i = 0; i < numSegments; i++) {
+    // Set up each segment so that they're fully allocated to the extents of the existing buffers.
+
+    const buffer = Arena.getBuffer(i, m._capnp.arena);
+    const segment = new Segment(i, m, buffer, buffer.byteLength);
+
+    m._capnp.segments[i] = segment;
+  }
+}
+
+function isArrayBufferView(src: ArrayBuffer | ArrayBufferView): src is ArrayBufferView {
+  return (src as { byteOffset?: number }).byteOffset !== undefined;
+}
+
+function isAnyArena(o: unknown): o is AnyArena {
+  return (o as { kind?: ArenaKind }).kind !== undefined;
+}
+
+export function allocateSegment(byteLength: number, m: Message): Segment {
+  trace("allocating %x bytes for %s", byteLength, m);
+
+  const res = Arena.allocate(byteLength, m._capnp.segments, m._capnp.arena);
+  let s: Segment;
+
+  if (res.id === m._capnp.segments.length) {
+    // Note how we're only allowing new segments in if they're exactly the next one in the array. There is no logical
+    // reason for segments to be created out of order.
+
+    s = new Segment(res.id, m, res.buffer);
+
+    trace("adding new segment %s", s);
+
+    m._capnp.segments.push(s);
+  } else if (res.id < 0 || res.id > m._capnp.segments.length) {
+    throw new Error(format(MSG_SEGMENT_OUT_OF_BOUNDS, res.id, m));
+  } else {
+    s = m._capnp.segments[res.id];
+
+    trace("replacing segment %s with buffer (len:%d)", s, res.buffer.byteLength);
+
+    s.replaceBuffer(res.buffer);
+  }
+
+  return s;
+}
+
+export function dump(m: Message): string {
+  let r = "";
+
+  if (m._capnp.segments.length === 0) {
+    return "================\nNo Segments\n================\n";
+  }
+
+  for (let i = 0; i < m._capnp.segments.length; i++) {
+    r += `================\nSegment #${i}\n================\n`;
+
+    const { buffer, byteLength } = m._capnp.segments[i];
+    const b = new Uint8Array(buffer, 0, byteLength);
+
+    r += dumpBuffer(b);
+  }
+
+  return r;
+}
+
+export function getRoot<T extends Struct>(RootStruct: StructCtor<T>, m: Message): T {
+  const root = new RootStruct(m.getSegment(0), 0);
+
+  validate(PointerType.STRUCT, root);
+
+  const ts = getTargetStructSize(root);
+
+  // Make sure the underlying pointer is actually big enough to hold the data and pointers as specified in the schema.
+  // If not a shallow copy of the struct contents needs to be made before returning.
+
+  if (
+    ts.dataByteLength < RootStruct._capnp.size.dataByteLength ||
+    ts.pointerLength < RootStruct._capnp.size.pointerLength
+  ) {
+    trace("need to resize root struct %s", root);
+
+    resize(RootStruct._capnp.size, root);
+  }
+
+  return root;
+}
+
+export function getSegment(id: number, m: Message): Segment {
+  const segmentLength = m._capnp.segments.length;
+
+  if (id === 0 && segmentLength === 0) {
+    // Segment zero is special. If we have no segments in the arena we'll want to allocate a new one and leave room
+    // for the root pointer.
+
+    const arenaSegments = Arena.getNumSegments(m._capnp.arena);
+
+    if (arenaSegments === 0) {
+      allocateSegment(DEFAULT_BUFFER_SIZE, m);
+    } else {
+      // Okay, the arena already has a buffer we can use. This is totally fine.
+
+      m._capnp.segments[0] = new Segment(0, m, Arena.getBuffer(0, m._capnp.arena));
+    }
+
+    if (!m._capnp.segments[0].hasCapacity(8)) {
+      throw new Error(MSG_SEGMENT_TOO_SMALL);
+    }
+
+    // This will leave room for the root pointer.
+
+    m._capnp.segments[0].allocate(8);
+
+    return m._capnp.segments[0];
+  }
+
+  if (id < 0 || id >= segmentLength) {
+    throw new Error(format(MSG_SEGMENT_OUT_OF_BOUNDS, id, m));
+  }
+
+  return m._capnp.segments[id];
+}
+
+export function initRoot<T extends Struct>(RootStruct: StructCtor<T>, m: Message): T {
+  const root = new RootStruct(m.getSegment(0), 0);
+
+  initStruct(RootStruct._capnp.size, root);
+
+  trace("Initialized root pointer %s for %s.", root, m);
+
+  return root;
+}
+
+/**
+ * Read a pointer in raw form (a packed message with framing headers). Does not
+ * care or attempt to validate the input beyond parsing the message
+ * segments.
+ *
+ * This is typically used by the compiler to load default values, but can be
+ * useful to work with messages with an unknown schema.
+ *
+ * @param {ArrayBuffer} data The raw data to read.
+ * @returns {Pointer} A root pointer.
+ */
+
+export function readRawPointer(data: ArrayBuffer): Pointer {
+  return new Pointer(new Message(data).getSegment(0), 0);
+}
+
+export function setRoot(src: Pointer, m: Message): void {
+  Pointer.copyFrom(src, new Pointer(m.getSegment(0), 0));
+}
+
+export function toArrayBuffer(m: Message): ArrayBuffer {
+  const streamFrame = getStreamFrame(m);
+
+  // Make sure the first segment is allocated.
+
+  if (m._capnp.segments.length === 0) getSegment(0, m);
+
+  const segments = m._capnp.segments;
+
+  // Add space for the stream framing.
+
+  const totalLength = streamFrame.byteLength + segments.reduce((l, s) => l + padToWord(s.byteLength), 0);
+  const out = new Uint8Array(new ArrayBuffer(totalLength));
+  let o = streamFrame.byteLength;
+
+  out.set(new Uint8Array(streamFrame));
+
+  segments.forEach((s) => {
+    const segmentLength = padToWord(s.byteLength);
+    out.set(new Uint8Array(s.buffer, 0, segmentLength), o);
+
+    o += segmentLength;
+  });
+
+  return out.buffer;
+}
+
+export function toPackedArrayBuffer(m: Message): ArrayBuffer {
+  const streamFrame = pack(getStreamFrame(m));
+
+  // Make sure the first segment is allocated.
+
+  if (m._capnp.segments.length === 0) m.getSegment(0);
+
+  // NOTE: A copy operation can be avoided here if we capture the intermediate array and use that directly in the copy
+  // loop below, rather than have `pack()` copy it to an ArrayBuffer just to have to copy it again later. If the
+  // intermediate array can be avoided altogether that's even better!
+  const segments = m._capnp.segments.map((s) => pack(s.buffer, 0, padToWord(s.byteLength)));
+
+  const totalLength = streamFrame.byteLength + segments.reduce((l, s) => l + s.byteLength, 0);
+  const out = new Uint8Array(new ArrayBuffer(totalLength));
+  let o = streamFrame.byteLength;
+
+  out.set(new Uint8Array(streamFrame));
+
+  segments.forEach((s) => {
+    out.set(new Uint8Array(s), o);
+
+    o += s.byteLength;
+  });
+
+  return out.buffer;
+}
+
+export function getStreamFrame(m: Message): ArrayBuffer {
+  const length = m._capnp.segments.length;
+
+  if (length === 0) {
+    // Don't bother allocating the first segment, just return a single zero word for the frame header.
+
+    return new Float64Array(1).buffer;
+  }
+
+  const frameLength = 4 + length * 4 + (1 - (length % 2)) * 4;
+  const out = new DataView(new ArrayBuffer(frameLength));
+
+  trace("Writing message stream frame with segment count: %d.", length);
+
+  out.setUint32(0, length - 1, true);
+
+  m._capnp.segments.forEach((s, i) => {
+    trace("Message segment %d word count: %d.", s.id, s.byteLength / 8);
+
+    out.setUint32(i * 4 + 4, s.byteLength / 8, true);
+  });
+
+  return out.buffer;
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/object-size.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @author jdiaz5513
+ */
+/**
+ * A simple object that describes the size of a struct.
+ *
+ * @export
+ * @class ObjectSize
+ */
+export declare class ObjectSize {
+    /** The number of bytes required for the data section. */
+    readonly dataByteLength: number;
+    /** The number of pointers in the object. */
+    readonly pointerLength: number;
+    constructor(dataByteLength: number, pointerCount: number);
+    toString(): string;
+}
+export declare function getByteLength(o: ObjectSize): number;
+export declare function getDataWordLength(o: ObjectSize): number;
+export declare function getWordLength(o: ObjectSize): number;
+export declare function padToWord(o: ObjectSize): ObjectSize;

workers1/auto3d/node_modules/capnp-ts/src/serialization/object-size.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padToWord = exports.getWordLength = exports.getDataWordLength = exports.getByteLength = exports.ObjectSize = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const _ = tslib_1.__importStar(require("../util"));
+const trace = debug_1.default("capnp:object-size");
+trace("load");
+/**
+ * A simple object that describes the size of a struct.
+ *
+ * @export
+ * @class ObjectSize
+ */
+class ObjectSize {
+    constructor(dataByteLength, pointerCount) {
+        this.dataByteLength = dataByteLength;
+        this.pointerLength = pointerCount;
+    }
+    toString() {
+        return _.format("ObjectSize_dw:%d,pc:%d", getDataWordLength(this), this.pointerLength);
+    }
+}
+exports.ObjectSize = ObjectSize;
+function getByteLength(o) {
+    return o.dataByteLength + o.pointerLength * 8;
+}
+exports.getByteLength = getByteLength;
+function getDataWordLength(o) {
+    return o.dataByteLength / 8;
+}
+exports.getDataWordLength = getDataWordLength;
+function getWordLength(o) {
+    return o.dataByteLength / 8 + o.pointerLength;
+}
+exports.getWordLength = getWordLength;
+function padToWord(o) {
+    return new ObjectSize(_.padToWord(o.dataByteLength), o.pointerLength);
+}
+exports.padToWord = padToWord;
+//# sourceMappingURL=object-size.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/object-size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-size.js","sourceRoot":"","sources":["object-size.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;AAEH,0DAA8B;AAE9B,mDAA6B;AAE7B,MAAM,KAAK,GAAG,eAAS,CAAC,mBAAmB,CAAC,CAAC;AAC7C,KAAK,CAAC,MAAM,CAAC,CAAC;AAEd;;;;;GAKG;AAEH,MAAa,UAAU;IASrB,YAAY,cAAsB,EAAE,YAAoB;QACtD,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;IACpC,CAAC;IAED,QAAQ;QACN,OAAO,CAAC,CAAC,MAAM,CACb,wBAAwB,EACxB,iBAAiB,CAAC,IAAI,CAAC,EACvB,IAAI,CAAC,aAAa,CACnB,CAAC;IACJ,CAAC;CACF;AArBD,gCAqBC;AAED,SAAgB,aAAa,CAAC,CAAa;IACzC,OAAO,CAAC,CAAC,cAAc,GAAG,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC;AAChD,CAAC;AAFD,sCAEC;AAED,SAAgB,iBAAiB,CAAC,CAAa;IAC7C,OAAO,CAAC,CAAC,cAAc,GAAG,CAAC,CAAC;AAC9B,CAAC;AAFD,8CAEC;AAED,SAAgB,aAAa,CAAC,CAAa;IACzC,OAAO,CAAC,CAAC,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,aAAa,CAAC;AAChD,CAAC;AAFD,sCAEC;AAED,SAAgB,SAAS,CAAC,CAAa;IACrC,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC;AACxE,CAAC;AAFD,8BAEC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/object-size.ts

@@ -0,0 +1,56 @@
+/**
+ * @author jdiaz5513
+ */
+
+import initTrace from "debug";
+
+import * as _ from "../util";
+
+const trace = initTrace("capnp:object-size");
+trace("load");
+
+/**
+ * A simple object that describes the size of a struct.
+ *
+ * @export
+ * @class ObjectSize
+ */
+
+export class ObjectSize {
+  /** The number of bytes required for the data section. */
+
+  readonly dataByteLength: number;
+
+  /** The number of pointers in the object. */
+
+  readonly pointerLength: number;
+
+  constructor(dataByteLength: number, pointerCount: number) {
+    this.dataByteLength = dataByteLength;
+    this.pointerLength = pointerCount;
+  }
+
+  toString(): string {
+    return _.format(
+      "ObjectSize_dw:%d,pc:%d",
+      getDataWordLength(this),
+      this.pointerLength
+    );
+  }
+}
+
+export function getByteLength(o: ObjectSize): number {
+  return o.dataByteLength + o.pointerLength * 8;
+}
+
+export function getDataWordLength(o: ObjectSize): number {
+  return o.dataByteLength / 8;
+}
+
+export function getWordLength(o: ObjectSize): number {
+  return o.dataByteLength / 8 + o.pointerLength;
+}
+
+export function padToWord(o: ObjectSize): ObjectSize {
+  return new ObjectSize(_.padToWord(o.dataByteLength), o.pointerLength);
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/packing.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @author jdiaz5513
+ */
+/**
+ * Compute the Hamming weight (number of bits set to 1) of a number. Used to figure out how many bytes follow a tag byte
+ * while computing the size of a packed message.
+ *
+ * WARNING: Using this with floating point numbers will void your warranty.
+ *
+ * @param {number} x A real integer.
+ * @returns {number} The hamming weight (integer).
+ */
+export declare function getHammingWeight(x: number): number;
+export declare type byte = number;
+/**
+ * Compute the tag byte from the 8 bytes of a 64-bit word.
+ *
+ * @param {byte} a The first byte.
+ * @param {byte} b The second byte.
+ * @param {byte} c The third byte.
+ * @param {byte} d The fourth byte.
+ * @param {byte} e The fifth byte.
+ * @param {byte} f The sixth byte.
+ * @param {byte} g The seventh byte.
+ * @param {byte} h The eighth byte (phew!).
+ * @returns {number} The tag byte.
+ */
+export declare function getTagByte(a: byte, b: byte, c: byte, d: byte, e: byte, f: byte, g: byte, h: byte): number;
+/**
+ * Efficiently calculate the length of a packed Cap'n Proto message.
+ *
+ * @export
+ * @param {ArrayBuffer} packed The packed message.
+ * @returns {number} The length of the unpacked message in bytes.
+ */
+export declare function getUnpackedByteLength(packed: ArrayBuffer): number;
+/**
+ * Compute the number of zero bytes that occur in a given 64-bit word, provided as eight separate bytes.
+ *
+ * @param {byte} a The first byte.
+ * @param {byte} b The second byte.
+ * @param {byte} c The third byte.
+ * @param {byte} d The fourth byte.
+ * @param {byte} e The fifth byte.
+ * @param {byte} f The sixth byte.
+ * @param {byte} g The seventh byte.
+ * @param {byte} h The eighth byte (phew!).
+ * @returns {number} The number of these bytes that are zero.
+ */
+export declare function getZeroByteCount(a: byte, b: byte, c: byte, d: byte, e: byte, f: byte, g: byte, h: byte): number;
+/**
+ * Pack a section of a Cap'n Proto message into a compressed format. This will efficiently compress zero bytes (which
+ * are common in idiomatic Cap'n Proto messages) into a compact form.
+ *
+ * For stream-framed messages this is called once for the frame header and once again for each segment in the message.
+ *
+ * The returned array buffer is trimmed to the exact size of the packed message with a single copy operation at the end.
+ * This should be decent on CPU time but does require quite a lot of memory (a normal array is filled up with each
+ * packed byte until the packing is complete).
+ *
+ * @export
+ * @param {ArrayBuffer} unpacked The message to pack.
+ * @param {number} [byteOffset] Starting byte offset to read bytes from, defaults to 0.
+ * @param {number} [byteLength] Total number of bytes to read, defaults to the remainder of the buffer contents.
+ * @returns {ArrayBuffer} A packed version of the message.
+ */
+export declare function pack(unpacked: ArrayBuffer, byteOffset?: number, byteLength?: number): ArrayBuffer;
+/**
+ * Unpack a compressed Cap'n Proto message into a new ArrayBuffer.
+ *
+ * Unlike the `pack` function, this is able to efficiently determine the exact size needed for the output buffer and
+ * runs considerably more efficiently.
+ *
+ * @export
+ * @param {ArrayBuffer} packed An array buffer containing the packed message.
+ * @returns {ArrayBuffer} The unpacked message.
+ */
+export declare function unpack(packed: ArrayBuffer): ArrayBuffer;

workers1/auto3d/node_modules/capnp-ts/src/serialization/packing.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpack = exports.pack = exports.getZeroByteCount = exports.getUnpackedByteLength = exports.getTagByte = exports.getHammingWeight = void 0;
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
+/**
+ * Compute the Hamming weight (number of bits set to 1) of a number. Used to figure out how many bytes follow a tag byte
+ * while computing the size of a packed message.
+ *
+ * WARNING: Using this with floating point numbers will void your warranty.
+ *
+ * @param {number} x A real integer.
+ * @returns {number} The hamming weight (integer).
+ */
+function getHammingWeight(x) {
+    // Thanks, HACKMEM!
+    let w = x - ((x >> 1) & 0x55555555);
+    w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
+    return (((w + (w >> 4)) & 0x0f0f0f0f) * 0x01010101) >> 24;
+}
+exports.getHammingWeight = getHammingWeight;
+/**
+ * Compute the tag byte from the 8 bytes of a 64-bit word.
+ *
+ * @param {byte} a The first byte.
+ * @param {byte} b The second byte.
+ * @param {byte} c The third byte.
+ * @param {byte} d The fourth byte.
+ * @param {byte} e The fifth byte.
+ * @param {byte} f The sixth byte.
+ * @param {byte} g The seventh byte.
+ * @param {byte} h The eighth byte (phew!).
+ * @returns {number} The tag byte.
+ */
+function getTagByte(a, b, c, d, e, f, g, h) {
+    // Yes, it's pretty. Don't touch it.
+    return ((a === 0 ? 0 : 0b00000001) |
+        (b === 0 ? 0 : 0b00000010) |
+        (c === 0 ? 0 : 0b00000100) |
+        (d === 0 ? 0 : 0b00001000) |
+        (e === 0 ? 0 : 0b00010000) |
+        (f === 0 ? 0 : 0b00100000) |
+        (g === 0 ? 0 : 0b01000000) |
+        (h === 0 ? 0 : 0b10000000));
+}
+exports.getTagByte = getTagByte;
+/**
+ * Efficiently calculate the length of a packed Cap'n Proto message.
+ *
+ * @export
+ * @param {ArrayBuffer} packed The packed message.
+ * @returns {number} The length of the unpacked message in bytes.
+ */
+function getUnpackedByteLength(packed) {
+    const p = new Uint8Array(packed);
+    let wordLength = 0;
+    let lastTag = 0x77;
+    for (let i = 0; i < p.byteLength;) {
+        const tag = p[i];
+        if (lastTag === 0 /* ZERO */) {
+            wordLength += tag;
+            i++;
+            lastTag = 0x77;
+        }
+        else if (lastTag === 255 /* SPAN */) {
+            wordLength += tag;
+            i += tag * 8 + 1;
+            lastTag = 0x77;
+        }
+        else {
+            wordLength++;
+            i += getHammingWeight(tag) + 1;
+            lastTag = tag;
+        }
+    }
+    return wordLength * 8;
+}
+exports.getUnpackedByteLength = getUnpackedByteLength;
+/**
+ * Compute the number of zero bytes that occur in a given 64-bit word, provided as eight separate bytes.
+ *
+ * @param {byte} a The first byte.
+ * @param {byte} b The second byte.
+ * @param {byte} c The third byte.
+ * @param {byte} d The fourth byte.
+ * @param {byte} e The fifth byte.
+ * @param {byte} f The sixth byte.
+ * @param {byte} g The seventh byte.
+ * @param {byte} h The eighth byte (phew!).
+ * @returns {number} The number of these bytes that are zero.
+ */
+function getZeroByteCount(a, b, c, d, e, f, g, h) {
+    return ((a === 0 ? 1 : 0) +
+        (b === 0 ? 1 : 0) +
+        (c === 0 ? 1 : 0) +
+        (d === 0 ? 1 : 0) +
+        (e === 0 ? 1 : 0) +
+        (f === 0 ? 1 : 0) +
+        (g === 0 ? 1 : 0) +
+        (h === 0 ? 1 : 0));
+}
+exports.getZeroByteCount = getZeroByteCount;
+/**
+ * Pack a section of a Cap'n Proto message into a compressed format. This will efficiently compress zero bytes (which
+ * are common in idiomatic Cap'n Proto messages) into a compact form.
+ *
+ * For stream-framed messages this is called once for the frame header and once again for each segment in the message.
+ *
+ * The returned array buffer is trimmed to the exact size of the packed message with a single copy operation at the end.
+ * This should be decent on CPU time but does require quite a lot of memory (a normal array is filled up with each
+ * packed byte until the packing is complete).
+ *
+ * @export
+ * @param {ArrayBuffer} unpacked The message to pack.
+ * @param {number} [byteOffset] Starting byte offset to read bytes from, defaults to 0.
+ * @param {number} [byteLength] Total number of bytes to read, defaults to the remainder of the buffer contents.
+ * @returns {ArrayBuffer} A packed version of the message.
+ */
+function pack(unpacked, byteOffset = 0, byteLength) {
+    if (unpacked.byteLength % 8 !== 0)
+        throw new Error(errors_1.MSG_PACK_NOT_WORD_ALIGNED);
+    const src = new Uint8Array(unpacked, byteOffset, byteLength);
+    // TODO: Maybe we should do this with buffers? This costs more than 8x the final compressed size in temporary RAM.
+    const dst = [];
+    /* Just have to be sure it's neither ZERO nor SPAN. */
+    let lastTag = 0x77;
+    /** This is where we need to remember to write the SPAN tag (0xff). */
+    let spanTagOffset = NaN;
+    /** How many words have been copied during the current span. */
+    let spanWordLength = 0;
+    /**
+     * When this hits zero, we've had PACK_SPAN_THRESHOLD zero bytes pass by and it's time to bail from the span.
+     */
+    let spanThreshold = constants_1.PACK_SPAN_THRESHOLD;
+    for (let srcByteOffset = 0; srcByteOffset < src.byteLength; srcByteOffset += 8) {
+        /** Read in the entire word. Yes, this feels silly but it's fast! */
+        const a = src[srcByteOffset];
+        const b = src[srcByteOffset + 1];
+        const c = src[srcByteOffset + 2];
+        const d = src[srcByteOffset + 3];
+        const e = src[srcByteOffset + 4];
+        const f = src[srcByteOffset + 5];
+        const g = src[srcByteOffset + 6];
+        const h = src[srcByteOffset + 7];
+        const tag = getTagByte(a, b, c, d, e, f, g, h);
+        /** If this is true we'll skip the normal word write logic after the switch statement. */
+        let skipWriteWord = true;
+        switch (lastTag) {
+            case 0 /* ZERO */:
+                // We're writing a span of words with all zeroes in them. See if we need to bail out of the fast path.
+                if (tag !== 0 /* ZERO */ || spanWordLength >= 0xff) {
+                    // There's a bit in there or we got too many zeroes. Damn, we need to bail.
+                    dst.push(spanWordLength);
+                    spanWordLength = 0;
+                    skipWriteWord = false;
+                }
+                else {
+                    // Kay, let's quickly inc this and go.
+                    spanWordLength++;
+                }
+                break;
+            case 255 /* SPAN */: {
+                // We're writing a span of nonzero words.
+                const zeroCount = getZeroByteCount(a, b, c, d, e, f, g, h);
+                // See if we need to bail now.
+                spanThreshold -= zeroCount;
+                if (spanThreshold <= 0 || spanWordLength >= 0xff) {
+                    // Alright, time to get packing again. Write the number of words we skipped to the beginning of the span.
+                    dst[spanTagOffset] = spanWordLength;
+                    spanWordLength = 0;
+                    spanThreshold = constants_1.PACK_SPAN_THRESHOLD;
+                    // We have to write this word normally.
+                    skipWriteWord = false;
+                }
+                else {
+                    // Just write this word verbatim.
+                    dst.push(a, b, c, d, e, f, g, h);
+                    spanWordLength++;
+                }
+                break;
+            }
+            default:
+                // Didn't get a special tag last time, let's write this as normal.
+                skipWriteWord = false;
+                break;
+        }
+        // A goto is fast, idk why people keep hatin'.
+        if (skipWriteWord)
+            continue;
+        dst.push(tag);
+        lastTag = tag;
+        if (a !== 0)
+            dst.push(a);
+        if (b !== 0)
+            dst.push(b);
+        if (c !== 0)
+            dst.push(c);
+        if (d !== 0)
+            dst.push(d);
+        if (e !== 0)
+            dst.push(e);
+        if (f !== 0)
+            dst.push(f);
+        if (g !== 0)
+            dst.push(g);
+        if (h !== 0)
+            dst.push(h);
+        // Record the span tag offset if needed, making sure to actually leave room for it.
+        if (tag === 255 /* SPAN */) {
+            spanTagOffset = dst.length;
+            dst.push(0);
+        }
+    }
+    // We're done. If we were writing a span let's finish it.
+    if (lastTag === 0 /* ZERO */) {
+        dst.push(spanWordLength);
+    }
+    else if (lastTag === 255 /* SPAN */) {
+        dst[spanTagOffset] = spanWordLength;
+    }
+    return new Uint8Array(dst).buffer;
+}
+exports.pack = pack;
+/**
+ * Unpack a compressed Cap'n Proto message into a new ArrayBuffer.
+ *
+ * Unlike the `pack` function, this is able to efficiently determine the exact size needed for the output buffer and
+ * runs considerably more efficiently.
+ *
+ * @export
+ * @param {ArrayBuffer} packed An array buffer containing the packed message.
+ * @returns {ArrayBuffer} The unpacked message.
+ */
+function unpack(packed) {
+    // We have no choice but to read the packed buffer one byte at a time.
+    const src = new Uint8Array(packed);
+    const dst = new Uint8Array(new ArrayBuffer(getUnpackedByteLength(packed)));
+    /** The last tag byte that we've seen - it starts at a "neutral" value. */
+    let lastTag = 0x77;
+    for (let srcByteOffset = 0, dstByteOffset = 0; srcByteOffset < src.byteLength;) {
+        const tag = src[srcByteOffset];
+        if (lastTag === 0 /* ZERO */) {
+            // We have a span of zeroes. New array buffers are guaranteed to be initialized to zero so we just seek ahead.
+            dstByteOffset += tag * 8;
+            srcByteOffset++;
+            lastTag = 0x77;
+        }
+        else if (lastTag === 255 /* SPAN */) {
+            // We have a span of unpacked bytes. Copy them verbatim from the source buffer.
+            const spanByteLength = tag * 8;
+            dst.set(src.subarray(srcByteOffset + 1, srcByteOffset + 1 + spanByteLength), dstByteOffset);
+            dstByteOffset += spanByteLength;
+            srcByteOffset += 1 + spanByteLength;
+            lastTag = 0x77;
+        }
+        else {
+            // Okay, a normal tag. Let's read past the tag and copy bytes that have a bit set in the tag.
+            srcByteOffset++;
+            for (let i = 1; i <= 0b10000000; i <<= 1) {
+                // We only need to actually touch `dst` if there's a nonzero byte (it's already initialized to zeroes).
+                if ((tag & i) !== 0)
+                    dst[dstByteOffset] = src[srcByteOffset++];
+                dstByteOffset++;
+            }
+            lastTag = tag;
+        }
+    }
+    return dst.buffer;
+}
+exports.unpack = unpack;
+//# sourceMappingURL=packing.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/packing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packing.js","sourceRoot":"","sources":["packing.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,4CAAmD;AACnD,sCAAsD;AAmCtD;;;;;;;;GAQG;AAEH,SAAgB,gBAAgB,CAAC,CAAS;IACxC,mBAAmB;IAEnB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC;IACpC,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC;IAC/C,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;AAC5D,CAAC;AAND,4CAMC;AAID;;;;;;;;;;;;GAYG;AAEH,SAAgB,UAAU,CAAC,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO;IAC/F,oCAAoC;IAEpC,OAAO,CACL,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC1B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC1B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC1B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC1B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC1B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC1B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC1B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAC3B,CAAC;AACJ,CAAC;AAbD,gCAaC;AAED;;;;;;GAMG;AAEH,SAAgB,qBAAqB,CAAC,MAAmB;IACvD,MAAM,CAAC,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IACjC,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,OAAO,GAAG,IAAI,CAAC;IAEnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,GAAI;QAClC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAEjB,IAAI,OAAO,iBAAmB,EAAE;YAC9B,UAAU,IAAI,GAAG,CAAC;YAElB,CAAC,EAAE,CAAC;YAEJ,OAAO,GAAG,IAAI,CAAC;SAChB;aAAM,IAAI,OAAO,mBAAmB,EAAE;YACrC,UAAU,IAAI,GAAG,CAAC;YAElB,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;YAEjB,OAAO,GAAG,IAAI,CAAC;SAChB;aAAM;YACL,UAAU,EAAE,CAAC;YAEb,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAE/B,OAAO,GAAG,GAAG,CAAC;SACf;KACF;IAED,OAAO,UAAU,GAAG,CAAC,CAAC;AACxB,CAAC;AA9BD,sDA8BC;AAED;;;;;;;;;;;;GAYG;AAEH,SAAgB,gBAAgB,CAAC,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO,EAAE,CAAO;IACrG,OAAO,CACL,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAClB,CAAC;AACJ,CAAC;AAXD,4CAWC;AAED;;;;;;;;;;;;;;;GAeG;AAEH,SAAgB,IAAI,CAAC,QAAqB,EAAE,UAAU,GAAG,CAAC,EAAE,UAAmB;IAC7E,IAAI,QAAQ,CAAC,UAAU,GAAG,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,kCAAyB,CAAC,CAAC;IAE9E,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;IAE7D,kHAAkH;IAElH,MAAM,GAAG,GAAa,EAAE,CAAC;IAEzB,sDAAsD;IAEtD,IAAI,OAAO,GAAG,IAAI,CAAC;IAEnB,sEAAsE;IAEtE,IAAI,aAAa,GAAG,GAAG,CAAC;IAExB,+DAA+D;IAE/D,IAAI,cAAc,GAAG,CAAC,CAAC;IAEvB;;OAEG;IAEH,IAAI,aAAa,GAAG,+BAAmB,CAAC;IAExC,KAAK,IAAI,aAAa,GAAG,CAAC,EAAE,aAAa,GAAG,GAAG,CAAC,UAAU,EAAE,aAAa,IAAI,CAAC,EAAE;QAC9E,oEAAoE;QAEpE,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,CAAC;QAC7B,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;QAEjC,MAAM,GAAG,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAE/C,yFAAyF;QAEzF,IAAI,aAAa,GAAG,IAAI,CAAC;QAEzB,QAAQ,OAAO,EAAE;YACf;gBACE,sGAAsG;gBAEtG,IAAI,GAAG,iBAAmB,IAAI,cAAc,IAAI,IAAI,EAAE;oBACpD,2EAA2E;oBAE3E,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;oBACzB,cAAc,GAAG,CAAC,CAAC;oBAEnB,aAAa,GAAG,KAAK,CAAC;iBACvB;qBAAM;oBACL,sCAAsC;oBAEtC,cAAc,EAAE,CAAC;iBAClB;gBAED,MAAM;YAER,mBAAmB,CAAC,CAAC;gBACnB,yCAAyC;gBAEzC,MAAM,SAAS,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAE3D,8BAA8B;gBAE9B,aAAa,IAAI,SAAS,CAAC;gBAE3B,IAAI,aAAa,IAAI,CAAC,IAAI,cAAc,IAAI,IAAI,EAAE;oBAChD,yGAAyG;oBAEzG,GAAG,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC;oBACpC,cAAc,GAAG,CAAC,CAAC;oBAEnB,aAAa,GAAG,+BAAmB,CAAC;oBAEpC,uCAAuC;oBAEvC,aAAa,GAAG,KAAK,CAAC;iBACvB;qBAAM;oBACL,iCAAiC;oBAEjC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;oBAEjC,cAAc,EAAE,CAAC;iBAClB;gBAED,MAAM;aACP;YACD;gBACE,kEAAkE;gBAElE,aAAa,GAAG,KAAK,CAAC;gBAEtB,MAAM;SACT;QAED,8CAA8C;QAC9C,IAAI,aAAa;YAAE,SAAS;QAE5B,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACd,OAAO,GAAG,GAAG,CAAC;QAEd,IAAI,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAEzB,mFAAmF;QAEnF,IAAI,GAAG,mBAAmB,EAAE;YAC1B,aAAa,GAAG,GAAG,CAAC,MAAM,CAAC;YAE3B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACb;KACF;IAED,yDAAyD;IAEzD,IAAI,OAAO,iBAAmB,EAAE;QAC9B,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;KAC1B;SAAM,IAAI,OAAO,mBAAmB,EAAE;QACrC,GAAG,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC;KACrC;IAED,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;AACpC,CAAC;AAvID,oBAuIC;AAED;;;;;;;;;GASG;AAEH,SAAgB,MAAM,CAAC,MAAmB;IACxC,sEAAsE;IAEtE,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IACnC,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,IAAI,WAAW,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAE3E,0EAA0E;IAE1E,IAAI,OAAO,GAAG,IAAI,CAAC;IAEnB,KAAK,IAAI,aAAa,GAAG,CAAC,EAAE,aAAa,GAAG,CAAC,EAAE,aAAa,GAAG,GAAG,CAAC,UAAU,GAAI;QAC/E,MAAM,GAAG,GAAG,GAAG,CAAC,aAAa,CAAC,CAAC;QAE/B,IAAI,OAAO,iBAAmB,EAAE;YAC9B,8GAA8G;YAE9G,aAAa,IAAI,GAAG,GAAG,CAAC,CAAC;YAEzB,aAAa,EAAE,CAAC;YAEhB,OAAO,GAAG,IAAI,CAAC;SAChB;aAAM,IAAI,OAAO,mBAAmB,EAAE;YACrC,+EAA+E;YAE/E,MAAM,cAAc,GAAG,GAAG,GAAG,CAAC,CAAC;YAE/B,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,GAAG,CAAC,EAAE,aAAa,GAAG,CAAC,GAAG,cAAc,CAAC,EAAE,aAAa,CAAC,CAAC;YAE5F,aAAa,IAAI,cAAc,CAAC;YAChC,aAAa,IAAI,CAAC,GAAG,cAAc,CAAC;YAEpC,OAAO,GAAG,IAAI,CAAC;SAChB;aAAM;YACL,6FAA6F;YAE7F,aAAa,EAAE,CAAC;YAEhB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE;gBACxC,uGAAuG;gBAEvG,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC;oBAAE,GAAG,CAAC,aAAa,CAAC,GAAG,GAAG,CAAC,aAAa,EAAE,CAAC,CAAC;gBAE/D,aAAa,EAAE,CAAC;aACjB;YAED,OAAO,GAAG,GAAG,CAAC;SACf;KACF;IAED,OAAO,GAAG,CAAC,MAAM,CAAC;AACpB,CAAC;AAlDD,wBAkDC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/packing.ts

@@ -0,0 +1,372 @@
+/**
+ * @author jdiaz5513
+ */
+
+import { PACK_SPAN_THRESHOLD } from "../constants";
+import { MSG_PACK_NOT_WORD_ALIGNED } from "../errors";
+
+/**
+ * When packing a message there are two tags that are interpreted in a special way: `0x00` and `0xff`.
+ *
+ * @enum {number}
+ */
+
+const enum PackedTag {
+  /**
+   * The tag is followed by a single byte which indicates a count of consecutive zero-valued words, minus 1. E.g. if the
+   * tag 0x00 is followed by 0x05, the sequence unpacks to 6 words of zero.
+   *
+   * Or, put another way: the tag is first decoded as if it were not special. Since none of the bits are set, it is
+   * followed by no bytes and expands to a word full of zeros. After that, the next byte is interpreted as a count of
+   * additional words that are also all-zero.
+   */
+
+  ZERO = 0x00,
+
+  /**
+   * The tag is followed by the bytes of the word (as if it weren’t special), but after those bytes is another byte with
+   * value N. Following that byte is N unpacked words that should be copied directly.
+   *
+   * These unpacked words may contain zeroes; in this implementation a minimum of PACK_SPAN_THRESHOLD zero bytes are
+   * written before ending the span.
+   *
+   * The purpose of this rule is to minimize the impact of packing on data that doesn’t contain any zeros – in
+   * particular, long text blobs. Because of this rule, the worst-case space overhead of packing is 2 bytes per 2 KiB of
+   * input (256 words = 2KiB).
+   */
+
+  SPAN = 0xff,
+}
+
+/**
+ * Compute the Hamming weight (number of bits set to 1) of a number. Used to figure out how many bytes follow a tag byte
+ * while computing the size of a packed message.
+ *
+ * WARNING: Using this with floating point numbers will void your warranty.
+ *
+ * @param {number} x A real integer.
+ * @returns {number} The hamming weight (integer).
+ */
+
+export function getHammingWeight(x: number): number {
+  // Thanks, HACKMEM!
+
+  let w = x - ((x >> 1) & 0x55555555);
+  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
+  return (((w + (w >> 4)) & 0x0f0f0f0f) * 0x01010101) >> 24;
+}
+
+export type byte = number;
+
+/**
+ * Compute the tag byte from the 8 bytes of a 64-bit word.
+ *
+ * @param {byte} a The first byte.
+ * @param {byte} b The second byte.
+ * @param {byte} c The third byte.
+ * @param {byte} d The fourth byte.
+ * @param {byte} e The fifth byte.
+ * @param {byte} f The sixth byte.
+ * @param {byte} g The seventh byte.
+ * @param {byte} h The eighth byte (phew!).
+ * @returns {number} The tag byte.
+ */
+
+export function getTagByte(a: byte, b: byte, c: byte, d: byte, e: byte, f: byte, g: byte, h: byte): number {
+  // Yes, it's pretty. Don't touch it.
+
+  return (
+    (a === 0 ? 0 : 0b00000001) |
+    (b === 0 ? 0 : 0b00000010) |
+    (c === 0 ? 0 : 0b00000100) |
+    (d === 0 ? 0 : 0b00001000) |
+    (e === 0 ? 0 : 0b00010000) |
+    (f === 0 ? 0 : 0b00100000) |
+    (g === 0 ? 0 : 0b01000000) |
+    (h === 0 ? 0 : 0b10000000)
+  );
+}
+
+/**
+ * Efficiently calculate the length of a packed Cap'n Proto message.
+ *
+ * @export
+ * @param {ArrayBuffer} packed The packed message.
+ * @returns {number} The length of the unpacked message in bytes.
+ */
+
+export function getUnpackedByteLength(packed: ArrayBuffer): number {
+  const p = new Uint8Array(packed);
+  let wordLength = 0;
+  let lastTag = 0x77;
+
+  for (let i = 0; i < p.byteLength; ) {
+    const tag = p[i];
+
+    if (lastTag === PackedTag.ZERO) {
+      wordLength += tag;
+
+      i++;
+
+      lastTag = 0x77;
+    } else if (lastTag === PackedTag.SPAN) {
+      wordLength += tag;
+
+      i += tag * 8 + 1;
+
+      lastTag = 0x77;
+    } else {
+      wordLength++;
+
+      i += getHammingWeight(tag) + 1;
+
+      lastTag = tag;
+    }
+  }
+
+  return wordLength * 8;
+}
+
+/**
+ * Compute the number of zero bytes that occur in a given 64-bit word, provided as eight separate bytes.
+ *
+ * @param {byte} a The first byte.
+ * @param {byte} b The second byte.
+ * @param {byte} c The third byte.
+ * @param {byte} d The fourth byte.
+ * @param {byte} e The fifth byte.
+ * @param {byte} f The sixth byte.
+ * @param {byte} g The seventh byte.
+ * @param {byte} h The eighth byte (phew!).
+ * @returns {number} The number of these bytes that are zero.
+ */
+
+export function getZeroByteCount(a: byte, b: byte, c: byte, d: byte, e: byte, f: byte, g: byte, h: byte): number {
+  return (
+    (a === 0 ? 1 : 0) +
+    (b === 0 ? 1 : 0) +
+    (c === 0 ? 1 : 0) +
+    (d === 0 ? 1 : 0) +
+    (e === 0 ? 1 : 0) +
+    (f === 0 ? 1 : 0) +
+    (g === 0 ? 1 : 0) +
+    (h === 0 ? 1 : 0)
+  );
+}
+
+/**
+ * Pack a section of a Cap'n Proto message into a compressed format. This will efficiently compress zero bytes (which
+ * are common in idiomatic Cap'n Proto messages) into a compact form.
+ *
+ * For stream-framed messages this is called once for the frame header and once again for each segment in the message.
+ *
+ * The returned array buffer is trimmed to the exact size of the packed message with a single copy operation at the end.
+ * This should be decent on CPU time but does require quite a lot of memory (a normal array is filled up with each
+ * packed byte until the packing is complete).
+ *
+ * @export
+ * @param {ArrayBuffer} unpacked The message to pack.
+ * @param {number} [byteOffset] Starting byte offset to read bytes from, defaults to 0.
+ * @param {number} [byteLength] Total number of bytes to read, defaults to the remainder of the buffer contents.
+ * @returns {ArrayBuffer} A packed version of the message.
+ */
+
+export function pack(unpacked: ArrayBuffer, byteOffset = 0, byteLength?: number): ArrayBuffer {
+  if (unpacked.byteLength % 8 !== 0) throw new Error(MSG_PACK_NOT_WORD_ALIGNED);
+
+  const src = new Uint8Array(unpacked, byteOffset, byteLength);
+
+  // TODO: Maybe we should do this with buffers? This costs more than 8x the final compressed size in temporary RAM.
+
+  const dst: number[] = [];
+
+  /* Just have to be sure it's neither ZERO nor SPAN. */
+
+  let lastTag = 0x77;
+
+  /** This is where we need to remember to write the SPAN tag (0xff). */
+
+  let spanTagOffset = NaN;
+
+  /** How many words have been copied during the current span. */
+
+  let spanWordLength = 0;
+
+  /**
+   * When this hits zero, we've had PACK_SPAN_THRESHOLD zero bytes pass by and it's time to bail from the span.
+   */
+
+  let spanThreshold = PACK_SPAN_THRESHOLD;
+
+  for (let srcByteOffset = 0; srcByteOffset < src.byteLength; srcByteOffset += 8) {
+    /** Read in the entire word. Yes, this feels silly but it's fast! */
+
+    const a = src[srcByteOffset];
+    const b = src[srcByteOffset + 1];
+    const c = src[srcByteOffset + 2];
+    const d = src[srcByteOffset + 3];
+    const e = src[srcByteOffset + 4];
+    const f = src[srcByteOffset + 5];
+    const g = src[srcByteOffset + 6];
+    const h = src[srcByteOffset + 7];
+
+    const tag = getTagByte(a, b, c, d, e, f, g, h);
+
+    /** If this is true we'll skip the normal word write logic after the switch statement. */
+
+    let skipWriteWord = true;
+
+    switch (lastTag) {
+      case PackedTag.ZERO:
+        // We're writing a span of words with all zeroes in them. See if we need to bail out of the fast path.
+
+        if (tag !== PackedTag.ZERO || spanWordLength >= 0xff) {
+          // There's a bit in there or we got too many zeroes. Damn, we need to bail.
+
+          dst.push(spanWordLength);
+          spanWordLength = 0;
+
+          skipWriteWord = false;
+        } else {
+          // Kay, let's quickly inc this and go.
+
+          spanWordLength++;
+        }
+
+        break;
+
+      case PackedTag.SPAN: {
+        // We're writing a span of nonzero words.
+
+        const zeroCount = getZeroByteCount(a, b, c, d, e, f, g, h);
+
+        // See if we need to bail now.
+
+        spanThreshold -= zeroCount;
+
+        if (spanThreshold <= 0 || spanWordLength >= 0xff) {
+          // Alright, time to get packing again. Write the number of words we skipped to the beginning of the span.
+
+          dst[spanTagOffset] = spanWordLength;
+          spanWordLength = 0;
+
+          spanThreshold = PACK_SPAN_THRESHOLD;
+
+          // We have to write this word normally.
+
+          skipWriteWord = false;
+        } else {
+          // Just write this word verbatim.
+
+          dst.push(a, b, c, d, e, f, g, h);
+
+          spanWordLength++;
+        }
+
+        break;
+      }
+      default:
+        // Didn't get a special tag last time, let's write this as normal.
+
+        skipWriteWord = false;
+
+        break;
+    }
+
+    // A goto is fast, idk why people keep hatin'.
+    if (skipWriteWord) continue;
+
+    dst.push(tag);
+    lastTag = tag;
+
+    if (a !== 0) dst.push(a);
+    if (b !== 0) dst.push(b);
+    if (c !== 0) dst.push(c);
+    if (d !== 0) dst.push(d);
+    if (e !== 0) dst.push(e);
+    if (f !== 0) dst.push(f);
+    if (g !== 0) dst.push(g);
+    if (h !== 0) dst.push(h);
+
+    // Record the span tag offset if needed, making sure to actually leave room for it.
+
+    if (tag === PackedTag.SPAN) {
+      spanTagOffset = dst.length;
+
+      dst.push(0);
+    }
+  }
+
+  // We're done. If we were writing a span let's finish it.
+
+  if (lastTag === PackedTag.ZERO) {
+    dst.push(spanWordLength);
+  } else if (lastTag === PackedTag.SPAN) {
+    dst[spanTagOffset] = spanWordLength;
+  }
+
+  return new Uint8Array(dst).buffer;
+}
+
+/**
+ * Unpack a compressed Cap'n Proto message into a new ArrayBuffer.
+ *
+ * Unlike the `pack` function, this is able to efficiently determine the exact size needed for the output buffer and
+ * runs considerably more efficiently.
+ *
+ * @export
+ * @param {ArrayBuffer} packed An array buffer containing the packed message.
+ * @returns {ArrayBuffer} The unpacked message.
+ */
+
+export function unpack(packed: ArrayBuffer): ArrayBuffer {
+  // We have no choice but to read the packed buffer one byte at a time.
+
+  const src = new Uint8Array(packed);
+  const dst = new Uint8Array(new ArrayBuffer(getUnpackedByteLength(packed)));
+
+  /** The last tag byte that we've seen - it starts at a "neutral" value. */
+
+  let lastTag = 0x77;
+
+  for (let srcByteOffset = 0, dstByteOffset = 0; srcByteOffset < src.byteLength; ) {
+    const tag = src[srcByteOffset];
+
+    if (lastTag === PackedTag.ZERO) {
+      // We have a span of zeroes. New array buffers are guaranteed to be initialized to zero so we just seek ahead.
+
+      dstByteOffset += tag * 8;
+
+      srcByteOffset++;
+
+      lastTag = 0x77;
+    } else if (lastTag === PackedTag.SPAN) {
+      // We have a span of unpacked bytes. Copy them verbatim from the source buffer.
+
+      const spanByteLength = tag * 8;
+
+      dst.set(src.subarray(srcByteOffset + 1, srcByteOffset + 1 + spanByteLength), dstByteOffset);
+
+      dstByteOffset += spanByteLength;
+      srcByteOffset += 1 + spanByteLength;
+
+      lastTag = 0x77;
+    } else {
+      // Okay, a normal tag. Let's read past the tag and copy bytes that have a bit set in the tag.
+
+      srcByteOffset++;
+
+      for (let i = 1; i <= 0b10000000; i <<= 1) {
+        // We only need to actually touch `dst` if there's a nonzero byte (it's already initialized to zeroes).
+
+        if ((tag & i) !== 0) dst[dstByteOffset] = src[srcByteOffset++];
+
+        dstByteOffset++;
+      }
+
+      lastTag = tag;
+    }
+  }
+
+  return dst.buffer;
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/any-pointer-list.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author jdiaz5513
+ */
+import { ListCtor } from "./list";
+import { Pointer } from "./pointer";
+export declare const AnyPointerList: ListCtor<Pointer>;

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/any-pointer-list.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyPointerList = void 0;
+const pointer_1 = require("./pointer");
+const pointer_list_1 = require("./pointer-list");
+exports.AnyPointerList = pointer_list_1.PointerList(pointer_1.Pointer);
+//# sourceMappingURL=any-pointer-list.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/any-pointer-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"any-pointer-list.js","sourceRoot":"","sources":["any-pointer-list.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAGH,uCAAoC;AACpC,iDAA6C;AAEhC,QAAA,cAAc,GAAsB,0BAAW,CAAC,iBAAO,CAAC,CAAC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/any-pointer-list.ts

@@ -0,0 +1,9 @@
+/**
+ * @author jdiaz5513
+ */
+
+import { ListCtor } from "./list";
+import { Pointer } from "./pointer";
+import { PointerList } from "./pointer-list";
+
+export const AnyPointerList: ListCtor<Pointer> = PointerList(Pointer);

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/bool-list.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @author jdiaz5513
+ */
+import { _ListCtor, List } from "./list";
+export declare class BoolList extends List<boolean> {
+    static readonly _capnp: _ListCtor;
+    get(index: number): boolean;
+    set(index: number, value: boolean): void;
+    toString(): string;
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/bool-list.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoolList = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const list_element_size_1 = require("../list-element-size");
+const list_1 = require("./list");
+const pointer_1 = require("./pointer");
+const trace = debug_1.default("capnp:list:composite");
+trace("load");
+class BoolList extends list_1.List {
+    get(index) {
+        const bitMask = 1 << index % 8;
+        const byteOffset = index >>> 3;
+        const c = pointer_1.getContent(this);
+        const v = c.segment.getUint8(c.byteOffset + byteOffset);
+        return (v & bitMask) !== 0;
+    }
+    set(index, value) {
+        const bitMask = 1 << index % 8;
+        const c = pointer_1.getContent(this);
+        const byteOffset = c.byteOffset + (index >>> 3);
+        const v = c.segment.getUint8(byteOffset);
+        c.segment.setUint8(byteOffset, value ? v | bitMask : v & ~bitMask);
+    }
+    toString() {
+        return `Bool_${super.toString()}`;
+    }
+}
+exports.BoolList = BoolList;
+BoolList._capnp = {
+    displayName: "List<boolean>",
+    size: list_element_size_1.ListElementSize.BIT
+};
+//# sourceMappingURL=bool-list.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/bool-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bool-list.js","sourceRoot":"","sources":["bool-list.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;AAEH,0DAA8B;AAE9B,4DAAuD;AACvD,iCAAyC;AACzC,uCAAuC;AAEvC,MAAM,KAAK,GAAG,eAAS,CAAC,sBAAsB,CAAC,CAAC;AAChD,KAAK,CAAC,MAAM,CAAC,CAAC;AAEd,MAAa,QAAS,SAAQ,WAAa;IAMzC,GAAG,CAAC,KAAa;QACf,MAAM,OAAO,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;QAC/B,MAAM,UAAU,GAAG,KAAK,KAAK,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,oBAAU,CAAC,IAAI,CAAC,CAAC;QAC3B,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,GAAG,UAAU,CAAC,CAAC;QAExD,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,GAAG,CAAC,KAAa,EAAE,KAAc;QAC/B,MAAM,OAAO,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,oBAAU,CAAC,IAAI,CAAC,CAAC;QAC3B,MAAM,UAAU,GAAG,CAAC,CAAC,UAAU,GAAG,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;QAChD,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QAEzC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACrE,CAAC;IAED,QAAQ;QACN,OAAO,QAAQ,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;IACpC,CAAC;;AA1BH,4BA2BC;AA1BiB,eAAM,GAAc;IAClC,WAAW,EAAE,eAAyB;IACtC,IAAI,EAAE,mCAAe,CAAC,GAAG;CAC1B,CAAC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/bool-list.ts

@@ -0,0 +1,41 @@
+/**
+ * @author jdiaz5513
+ */
+
+import initTrace from "debug";
+
+import { ListElementSize } from "../list-element-size";
+import { _ListCtor, List } from "./list";
+import { getContent } from "./pointer";
+
+const trace = initTrace("capnp:list:composite");
+trace("load");
+
+export class BoolList extends List<boolean> {
+  static readonly _capnp: _ListCtor = {
+    displayName: "List<boolean>" as string,
+    size: ListElementSize.BIT
+  };
+
+  get(index: number): boolean {
+    const bitMask = 1 << index % 8;
+    const byteOffset = index >>> 3;
+    const c = getContent(this);
+    const v = c.segment.getUint8(c.byteOffset + byteOffset);
+
+    return (v & bitMask) !== 0;
+  }
+
+  set(index: number, value: boolean): void {
+    const bitMask = 1 << index % 8;
+    const c = getContent(this);
+    const byteOffset = c.byteOffset + (index >>> 3);
+    const v = c.segment.getUint8(byteOffset);
+
+    c.segment.setUint8(byteOffset, value ? v | bitMask : v & ~bitMask);
+  }
+
+  toString(): string {
+    return `Bool_${super.toString()}`;
+  }
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/composite-list.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author jdiaz5513
+ */
+import { ListCtor } from "./list";
+import { Struct, StructCtor } from "./struct";
+export declare function CompositeList<T extends Struct>(CompositeClass: StructCtor<T>): ListCtor<T>;

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/composite-list.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeList = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const list_element_size_1 = require("../list-element-size");
+const list_1 = require("./list");
+const pointer_1 = require("./pointer");
+const trace = debug_1.default("capnp:list:composite");
+trace("load");
+function CompositeList(CompositeClass) {
+    var _a;
+    return _a = class extends list_1.List {
+            get(index) {
+                return new CompositeClass(this.segment, this.byteOffset, this._capnp.depthLimit - 1, index);
+            }
+            set(index, value) {
+                pointer_1.copyFrom(value, this.get(index));
+            }
+            toString() {
+                return `Composite_${super.toString()},cls:${CompositeClass.toString()}`;
+            }
+        },
+        _a._capnp = {
+            compositeSize: CompositeClass._capnp.size,
+            displayName: `List<${CompositeClass._capnp.displayName}>`,
+            size: list_element_size_1.ListElementSize.COMPOSITE,
+        },
+        _a;
+}
+exports.CompositeList = CompositeList;
+//# sourceMappingURL=composite-list.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/composite-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-list.js","sourceRoot":"","sources":["composite-list.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;AAEH,0DAA8B;AAE9B,4DAAuD;AACvD,iCAAmD;AAEnD,uCAAqC;AAErC,MAAM,KAAK,GAAG,eAAS,CAAC,sBAAsB,CAAC,CAAC;AAChD,KAAK,CAAC,MAAM,CAAC,CAAC;AAEd,SAAgB,aAAa,CAAmB,cAA6B;;IAC3E,YAAO,KAAM,SAAQ,WAAO;YAO1B,GAAG,CAAC,KAAa;gBACf,OAAO,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;YAC9F,CAAC;YAED,GAAG,CAAC,KAAa,EAAE,KAAQ;gBACzB,kBAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YACnC,CAAC;YAED,QAAQ;gBACN,OAAO,aAAa,KAAK,CAAC,QAAQ,EAAE,QAAQ,cAAc,CAAC,QAAQ,EAAE,EAAE,CAAC;YAC1E,CAAC;SACF;QAjBiB,SAAM,GAAc;YAClC,aAAa,EAAE,cAAc,CAAC,MAAM,CAAC,IAAI;YACzC,WAAW,EAAE,QAAQ,cAAc,CAAC,MAAM,CAAC,WAAW,GAAG;YACzD,IAAI,EAAE,mCAAe,CAAC,SAAS;SAC/B;WAaF;AACJ,CAAC;AApBD,sCAoBC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/composite-list.ts

@@ -0,0 +1,35 @@
+/**
+ * @author jdiaz5513
+ */
+
+import initTrace from "debug";
+
+import { ListElementSize } from "../list-element-size";
+import { _ListCtor, List, ListCtor } from "./list";
+import { Struct, StructCtor } from "./struct";
+import { copyFrom } from "./pointer";
+
+const trace = initTrace("capnp:list:composite");
+trace("load");
+
+export function CompositeList<T extends Struct>(CompositeClass: StructCtor<T>): ListCtor<T> {
+  return class extends List<T> {
+    static readonly _capnp: _ListCtor = {
+      compositeSize: CompositeClass._capnp.size,
+      displayName: `List<${CompositeClass._capnp.displayName}>`,
+      size: ListElementSize.COMPOSITE,
+    };
+
+    get(index: number): T {
+      return new CompositeClass(this.segment, this.byteOffset, this._capnp.depthLimit - 1, index);
+    }
+
+    set(index: number, value: T): void {
+      copyFrom(value, this.get(index));
+    }
+
+    toString(): string {
+      return `Composite_${super.toString()},cls:${CompositeClass.toString()}`;
+    }
+  };
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/data-list.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author jdiaz5513
+ */
+import { Data } from "./data";
+import { ListCtor } from "./list";
+export declare const DataList: ListCtor<Data>;

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/data-list.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataList = void 0;
+const data_1 = require("./data");
+const pointer_list_1 = require("./pointer-list");
+exports.DataList = pointer_list_1.PointerList(data_1.Data);
+//# sourceMappingURL=data-list.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/data-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-list.js","sourceRoot":"","sources":["data-list.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,iCAA8B;AAE9B,iDAA6C;AAEhC,QAAA,QAAQ,GAAmB,0BAAW,CAAC,WAAI,CAAC,CAAC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/data-list.ts

@@ -0,0 +1,9 @@
+/**
+ * @author jdiaz5513
+ */
+
+import { Data } from "./data";
+import { ListCtor } from "./list";
+import { PointerList } from "./pointer-list";
+
+export const DataList: ListCtor<Data> = PointerList(Data);

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/data.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @author jdiaz5513
+ */
+import { List } from "./list";
+import { Pointer } from "./pointer";
+/**
+ * A generic blob of bytes. Can be converted to a DataView or Uint8Array to access its contents using `toDataView()` and
+ * `toUint8Array()`. Use `copyBuffer()` to copy an entire buffer at once.
+ *
+ * @export
+ * @class Data
+ * @extends {List<number>}
+ */
+export declare class Data extends List<number> {
+    static fromPointer(pointer: Pointer): Data;
+    protected static _fromPointerUnchecked(pointer: Pointer): Data;
+    /**
+     * Copy the contents of `src` into this Data pointer. If `src` is smaller than the length of this pointer then the
+     * remaining bytes will be zeroed out. Extra bytes in `src` are ignored.
+     *
+     * @param {(ArrayBuffer | ArrayBufferView)} src The source buffer.
+     * @returns {void}
+     */
+    copyBuffer(src: ArrayBuffer | ArrayBufferView): void;
+    /**
+     * Read a byte from the specified offset.
+     *
+     * @param {number} byteOffset The byte offset to read.
+     * @returns {number} The byte value.
+     */
+    get(byteOffset: number): number;
+    /**
+     * Write a byte at the specified offset.
+     *
+     * @param {number} byteOffset The byte offset to set.
+     * @param {number} value The byte value to set.
+     * @returns {void}
+     */
+    set(byteOffset: number, value: number): void;
+    /**
+     * Creates a **copy** of the underlying buffer data and returns it as an ArrayBuffer.
+     *
+     * To obtain a reference to the underlying buffer instead, use `toUint8Array()` or `toDataView()`.
+     *
+     * @returns {ArrayBuffer} A copy of this data buffer.
+     */
+    toArrayBuffer(): ArrayBuffer;
+    /**
+     * Convert this Data pointer to a DataView representing the pointer's contents.
+     *
+     * WARNING: The DataView references memory from a message segment, so do not venture outside the bounds of the
+     * DataView or else BAD THINGS.
+     *
+     * @returns {DataView} A live reference to the underlying buffer.
+     */
+    toDataView(): DataView;
+    toString(): string;
+    /**
+     * Convert this Data pointer to a Uint8Array representing the pointer's contents.
+     *
+     * WARNING: The Uint8Array references memory from a message segment, so do not venture outside the bounds of the
+     * Uint8Array or else BAD THINGS.
+     *
+     * @returns {DataView} A live reference to the underlying buffer.
+     */
+    toUint8Array(): Uint8Array;
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/data.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Data = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const list_element_size_1 = require("../list-element-size");
+const list_1 = require("./list");
+const pointer_1 = require("./pointer");
+const pointer_type_1 = require("./pointer-type");
+const trace = debug_1.default("capnp:data");
+trace("load");
+/**
+ * A generic blob of bytes. Can be converted to a DataView or Uint8Array to access its contents using `toDataView()` and
+ * `toUint8Array()`. Use `copyBuffer()` to copy an entire buffer at once.
+ *
+ * @export
+ * @class Data
+ * @extends {List<number>}
+ */
+class Data extends list_1.List {
+    static fromPointer(pointer) {
+        pointer_1.validate(pointer_type_1.PointerType.LIST, pointer, list_element_size_1.ListElementSize.BYTE);
+        return this._fromPointerUnchecked(pointer);
+    }
+    static _fromPointerUnchecked(pointer) {
+        return new this(pointer.segment, pointer.byteOffset, pointer._capnp.depthLimit);
+    }
+    /**
+     * Copy the contents of `src` into this Data pointer. If `src` is smaller than the length of this pointer then the
+     * remaining bytes will be zeroed out. Extra bytes in `src` are ignored.
+     *
+     * @param {(ArrayBuffer | ArrayBufferView)} src The source buffer.
+     * @returns {void}
+     */
+    // TODO: Would be nice to have a way to zero-copy a buffer by allocating a new segment into the message with that
+    // buffer data.
+    copyBuffer(src) {
+        const c = pointer_1.getContent(this);
+        const dstLength = this.getLength();
+        const srcLength = src.byteLength;
+        const i = src instanceof ArrayBuffer
+            ? new Uint8Array(src)
+            : new Uint8Array(src.buffer, src.byteOffset, Math.min(dstLength, srcLength));
+        const o = new Uint8Array(c.segment.buffer, c.byteOffset, this.getLength());
+        o.set(i);
+        if (dstLength > srcLength) {
+            trace("Zeroing out remaining %d bytes after copy into %s.", dstLength - srcLength, this);
+            o.fill(0, srcLength, dstLength);
+        }
+        else if (dstLength < srcLength) {
+            trace("Truncated %d bytes from source buffer while copying to %s.", srcLength - dstLength, this);
+        }
+    }
+    /**
+     * Read a byte from the specified offset.
+     *
+     * @param {number} byteOffset The byte offset to read.
+     * @returns {number} The byte value.
+     */
+    get(byteOffset) {
+        const c = pointer_1.getContent(this);
+        return c.segment.getUint8(c.byteOffset + byteOffset);
+    }
+    /**
+     * Write a byte at the specified offset.
+     *
+     * @param {number} byteOffset The byte offset to set.
+     * @param {number} value The byte value to set.
+     * @returns {void}
+     */
+    set(byteOffset, value) {
+        const c = pointer_1.getContent(this);
+        c.segment.setUint8(c.byteOffset + byteOffset, value);
+    }
+    /**
+     * Creates a **copy** of the underlying buffer data and returns it as an ArrayBuffer.
+     *
+     * To obtain a reference to the underlying buffer instead, use `toUint8Array()` or `toDataView()`.
+     *
+     * @returns {ArrayBuffer} A copy of this data buffer.
+     */
+    toArrayBuffer() {
+        const c = pointer_1.getContent(this);
+        return c.segment.buffer.slice(c.byteOffset, c.byteOffset + this.getLength());
+    }
+    /**
+     * Convert this Data pointer to a DataView representing the pointer's contents.
+     *
+     * WARNING: The DataView references memory from a message segment, so do not venture outside the bounds of the
+     * DataView or else BAD THINGS.
+     *
+     * @returns {DataView} A live reference to the underlying buffer.
+     */
+    toDataView() {
+        const c = pointer_1.getContent(this);
+        return new DataView(c.segment.buffer, c.byteOffset, this.getLength());
+    }
+    toString() {
+        return `Data_${super.toString()}`;
+    }
+    /**
+     * Convert this Data pointer to a Uint8Array representing the pointer's contents.
+     *
+     * WARNING: The Uint8Array references memory from a message segment, so do not venture outside the bounds of the
+     * Uint8Array or else BAD THINGS.
+     *
+     * @returns {DataView} A live reference to the underlying buffer.
+     */
+    toUint8Array() {
+        const c = pointer_1.getContent(this);
+        return new Uint8Array(c.segment.buffer, c.byteOffset, this.getLength());
+    }
+}
+exports.Data = Data;
+//# sourceMappingURL=data.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/data.js.map

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

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/data.ts

@@ -0,0 +1,158 @@
+/**
+ * @author jdiaz5513
+ */
+
+import initTrace from "debug";
+
+import { ListElementSize } from "../list-element-size";
+import { List } from "./list";
+import { Pointer, validate, getContent } from "./pointer";
+import { PointerType } from "./pointer-type";
+
+const trace = initTrace("capnp:data");
+trace("load");
+
+/**
+ * A generic blob of bytes. Can be converted to a DataView or Uint8Array to access its contents using `toDataView()` and
+ * `toUint8Array()`. Use `copyBuffer()` to copy an entire buffer at once.
+ *
+ * @export
+ * @class Data
+ * @extends {List<number>}
+ */
+
+export class Data extends List<number> {
+  static fromPointer(pointer: Pointer): Data {
+    validate(PointerType.LIST, pointer, ListElementSize.BYTE);
+
+    return this._fromPointerUnchecked(pointer);
+  }
+
+  protected static _fromPointerUnchecked(pointer: Pointer): Data {
+    return new this(
+      pointer.segment,
+      pointer.byteOffset,
+      pointer._capnp.depthLimit
+    );
+  }
+
+  /**
+   * Copy the contents of `src` into this Data pointer. If `src` is smaller than the length of this pointer then the
+   * remaining bytes will be zeroed out. Extra bytes in `src` are ignored.
+   *
+   * @param {(ArrayBuffer | ArrayBufferView)} src The source buffer.
+   * @returns {void}
+   */
+
+  // TODO: Would be nice to have a way to zero-copy a buffer by allocating a new segment into the message with that
+  // buffer data.
+
+  copyBuffer(src: ArrayBuffer | ArrayBufferView): void {
+    const c = getContent(this);
+
+    const dstLength = this.getLength();
+    const srcLength = src.byteLength;
+
+    const i =
+      src instanceof ArrayBuffer
+        ? new Uint8Array(src)
+        : new Uint8Array(
+            src.buffer,
+            src.byteOffset,
+            Math.min(dstLength, srcLength)
+          );
+
+    const o = new Uint8Array(c.segment.buffer, c.byteOffset, this.getLength());
+
+    o.set(i);
+
+    if (dstLength > srcLength) {
+      trace(
+        "Zeroing out remaining %d bytes after copy into %s.",
+        dstLength - srcLength,
+        this
+      );
+
+      o.fill(0, srcLength, dstLength);
+    } else if (dstLength < srcLength) {
+      trace(
+        "Truncated %d bytes from source buffer while copying to %s.",
+        srcLength - dstLength,
+        this
+      );
+    }
+  }
+
+  /**
+   * Read a byte from the specified offset.
+   *
+   * @param {number} byteOffset The byte offset to read.
+   * @returns {number} The byte value.
+   */
+
+  get(byteOffset: number): number {
+    const c = getContent(this);
+    return c.segment.getUint8(c.byteOffset + byteOffset);
+  }
+
+  /**
+   * Write a byte at the specified offset.
+   *
+   * @param {number} byteOffset The byte offset to set.
+   * @param {number} value The byte value to set.
+   * @returns {void}
+   */
+
+  set(byteOffset: number, value: number): void {
+    const c = getContent(this);
+    c.segment.setUint8(c.byteOffset + byteOffset, value);
+  }
+
+  /**
+   * Creates a **copy** of the underlying buffer data and returns it as an ArrayBuffer.
+   *
+   * To obtain a reference to the underlying buffer instead, use `toUint8Array()` or `toDataView()`.
+   *
+   * @returns {ArrayBuffer} A copy of this data buffer.
+   */
+
+  toArrayBuffer(): ArrayBuffer {
+    const c = getContent(this);
+    return c.segment.buffer.slice(
+      c.byteOffset,
+      c.byteOffset + this.getLength()
+    );
+  }
+
+  /**
+   * Convert this Data pointer to a DataView representing the pointer's contents.
+   *
+   * WARNING: The DataView references memory from a message segment, so do not venture outside the bounds of the
+   * DataView or else BAD THINGS.
+   *
+   * @returns {DataView} A live reference to the underlying buffer.
+   */
+
+  toDataView(): DataView {
+    const c = getContent(this);
+    return new DataView(c.segment.buffer, c.byteOffset, this.getLength());
+  }
+
+  toString(): string {
+    return `Data_${super.toString()}`;
+  }
+
+  /**
+   * Convert this Data pointer to a Uint8Array representing the pointer's contents.
+   *
+   * WARNING: The Uint8Array references memory from a message segment, so do not venture outside the bounds of the
+   * Uint8Array or else BAD THINGS.
+   *
+   * @returns {DataView} A live reference to the underlying buffer.
+   */
+
+  toUint8Array(): Uint8Array {
+    const c = getContent(this);
+    return new Uint8Array(c.segment.buffer, c.byteOffset, this.getLength());
+  }
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/float32-list.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @author jdiaz5513
+ */
+import { _ListCtor, List } from "./list";
+export declare class Float32List extends List<number> {
+    static readonly _capnp: _ListCtor;
+    get(index: number): number;
+    set(index: number, value: number): void;
+    toString(): string;
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/float32-list.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float32List = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const list_element_size_1 = require("../list-element-size");
+const list_1 = require("./list");
+const pointer_1 = require("./pointer");
+const trace = debug_1.default("capnp:list:composite");
+trace("load");
+class Float32List extends list_1.List {
+    get(index) {
+        const c = pointer_1.getContent(this);
+        return c.segment.getFloat32(c.byteOffset + index * 4);
+    }
+    set(index, value) {
+        const c = pointer_1.getContent(this);
+        c.segment.setFloat32(c.byteOffset + index * 4, value);
+    }
+    toString() {
+        return `Float32_${super.toString()}`;
+    }
+}
+exports.Float32List = Float32List;
+Float32List._capnp = {
+    displayName: "List<Float32>",
+    size: list_element_size_1.ListElementSize.BYTE_4
+};
+//# sourceMappingURL=float32-list.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/float32-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"float32-list.js","sourceRoot":"","sources":["float32-list.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;AAEH,0DAA8B;AAE9B,4DAAuD;AACvD,iCAAyC;AACzC,uCAAuC;AAEvC,MAAM,KAAK,GAAG,eAAS,CAAC,sBAAsB,CAAC,CAAC;AAChD,KAAK,CAAC,MAAM,CAAC,CAAC;AAEd,MAAa,WAAY,SAAQ,WAAY;IAM3C,GAAG,CAAC,KAAa;QACf,MAAM,CAAC,GAAG,oBAAU,CAAC,IAAI,CAAC,CAAC;QAE3B,OAAO,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,GAAG,CAAC,KAAa,EAAE,KAAa;QAC9B,MAAM,CAAC,GAAG,oBAAU,CAAC,IAAI,CAAC,CAAC;QAE3B,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;IACxD,CAAC;IAED,QAAQ;QACN,OAAO,WAAW,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;IACvC,CAAC;;AApBH,kCAqBC;AApBiB,kBAAM,GAAc;IAClC,WAAW,EAAE,eAAyB;IACtC,IAAI,EAAE,mCAAe,CAAC,MAAM;CAC7B,CAAC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/float32-list.ts

@@ -0,0 +1,35 @@
+/**
+ * @author jdiaz5513
+ */
+
+import initTrace from "debug";
+
+import { ListElementSize } from "../list-element-size";
+import { _ListCtor, List } from "./list";
+import { getContent } from "./pointer";
+
+const trace = initTrace("capnp:list:composite");
+trace("load");
+
+export class Float32List extends List<number> {
+  static readonly _capnp: _ListCtor = {
+    displayName: "List<Float32>" as string,
+    size: ListElementSize.BYTE_4
+  };
+
+  get(index: number): number {
+    const c = getContent(this);
+
+    return c.segment.getFloat32(c.byteOffset + index * 4);
+  }
+
+  set(index: number, value: number): void {
+    const c = getContent(this);
+
+    c.segment.setFloat32(c.byteOffset + index * 4, value);
+  }
+
+  toString(): string {
+    return `Float32_${super.toString()}`;
+  }
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/float64-list.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @author jdiaz5513
+ */
+import { _ListCtor, List } from "./list";
+export declare class Float64List extends List<number> {
+    static readonly _capnp: _ListCtor;
+    get(index: number): number;
+    set(index: number, value: number): void;
+    toString(): string;
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/float64-list.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @author jdiaz5513
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float64List = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const list_element_size_1 = require("../list-element-size");
+const list_1 = require("./list");
+const pointer_1 = require("./pointer");
+const trace = debug_1.default("capnp:list:composite");
+trace("load");
+class Float64List extends list_1.List {
+    get(index) {
+        const c = pointer_1.getContent(this);
+        return c.segment.getFloat64(c.byteOffset + index * 8);
+    }
+    set(index, value) {
+        const c = pointer_1.getContent(this);
+        c.segment.setFloat64(c.byteOffset + index * 8, value);
+    }
+    toString() {
+        return `Float64_${super.toString()}`;
+    }
+}
+exports.Float64List = Float64List;
+Float64List._capnp = {
+    displayName: "List<Float64>",
+    size: list_element_size_1.ListElementSize.BYTE_8
+};
+//# sourceMappingURL=float64-list.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/float64-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"float64-list.js","sourceRoot":"","sources":["float64-list.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;AAEH,0DAA8B;AAE9B,4DAAuD;AACvD,iCAAyC;AACzC,uCAAuC;AAEvC,MAAM,KAAK,GAAG,eAAS,CAAC,sBAAsB,CAAC,CAAC;AAChD,KAAK,CAAC,MAAM,CAAC,CAAC;AAEd,MAAa,WAAY,SAAQ,WAAY;IAM3C,GAAG,CAAC,KAAa;QACf,MAAM,CAAC,GAAG,oBAAU,CAAC,IAAI,CAAC,CAAC;QAE3B,OAAO,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,GAAG,CAAC,KAAa,EAAE,KAAa;QAC9B,MAAM,CAAC,GAAG,oBAAU,CAAC,IAAI,CAAC,CAAC;QAE3B,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;IACxD,CAAC;IAED,QAAQ;QACN,OAAO,WAAW,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;IACvC,CAAC;;AApBH,kCAqBC;AApBiB,kBAAM,GAAc;IAClC,WAAW,EAAE,eAAyB;IACtC,IAAI,EAAE,mCAAe,CAAC,MAAM;CAC7B,CAAC"}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/float64-list.ts

@@ -0,0 +1,35 @@
+/**
+ * @author jdiaz5513
+ */
+
+import initTrace from "debug";
+
+import { ListElementSize } from "../list-element-size";
+import { _ListCtor, List } from "./list";
+import { getContent } from "./pointer";
+
+const trace = initTrace("capnp:list:composite");
+trace("load");
+
+export class Float64List extends List<number> {
+  static readonly _capnp: _ListCtor = {
+    displayName: "List<Float64>" as string,
+    size: ListElementSize.BYTE_8
+  };
+
+  get(index: number): number {
+    const c = getContent(this);
+
+    return c.segment.getFloat64(c.byteOffset + index * 8);
+  }
+
+  set(index: number, value: number): void {
+    const c = getContent(this);
+
+    c.segment.setFloat64(c.byteOffset + index * 8, value);
+  }
+
+  toString(): string {
+    return `Float64_${super.toString()}`;
+  }
+}

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/group.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=group.js.map

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/group.js.map

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

workers1/auto3d/node_modules/capnp-ts/src/serialization/pointers/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @author jdiaz5513
+ */
+export { AnyPointerList } from "./any-pointer-list";
+export { BoolList } from "./bool-list";
+export { CompositeList } from "./composite-list";
+export { Data } from "./data";
+export { DataList } from "./data-list";
+export { Float32List } from "./float32-list";
+export { Float64List } from "./float64-list";
+export { Int8List } from "./int8-list";
+export { Int16List } from "./int16-list";
+export { Int32List } from "./int32-list";
+export { Int64List } from "./int64-list";
+export { Interface } from "./interface";
+export { InterfaceList } from "./interface-list";
+export { List, ListCtor } from "./list";
+export { Orphan } from "./orphan";
+export { PointerList } from "./pointer-list";
+export { PointerType } from "./pointer-type";
+export { Pointer } from "./pointer";
+export { _StructCtor, Struct, StructCtor } from "./struct";
+export { Text } from "./text";
+export { TextList } from "./text-list";
+export { Uint8List } from "./uint8-list";
+export { Uint16List } from "./uint16-list";
+export { Uint32List } from "./uint32-list";
+export { Uint64List } from "./uint64-list";
+export { Void, VOID } from "./void";
+export { VoidList } from "./void-list";