snxraven/bare-operating-system
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
db6dfa22e3d61218e7143021bb597f12657eaf32
bare-operating-system/kernel/lib/bare/bundles/bareBuffer.js
T
Raven Scott 9bdecc4170
Release rolling / release (push) Successful in 11m16s
Details
Sync Holepunch modules to current clone/npm latest 
Bump published pins (compact-encoding 3, bare-fetch/tls/https/ws 3,
bare-subprocess 6, bare-signals 5, corestore 7.12, protomux 3.11,
hypercore-crypto 3.7, bare-runtime 1.31) and regenerate catalogs,
manifests, and kernel/seeder bundles.

Adapt call sites to the new APIs:
- Corestore: explicit session flush before suspend(); treeCache ctor opts
- bare-crypto: KeyObject.export() instead of removed ._key
- Protomux 3.11: wait for fullyOpened()/fullyClosed() on chat channels
- bare-fetch: surface response.type and Headers.getSetCookie
- host snapshots: bare-os 3.9 / bare-posix / bare-fs.statfs frsize
- bare-subprocess 6: optional IPC channel + json serialization

Keep catalog sync from wiping curated pearEntries. Teach the Node test
shim to stub bare-thread/bare-worker (ESM absolute paths) and chain
Bare.on so bare-timers can load. Booter 479, protocol 34, seeder 14.
2026-08-12 20:56:28 -04:00

1134 lines
47 KiB
JavaScript
Raw Blame History

var __bare_os_bundle_exports__ = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// ../../node_modules/bare-buffer/binding.js
var require_binding = __commonJS({
"../../node_modules/bare-buffer/binding.js"(exports, module) {
module.exports = __require.addon();
}
});
// ../../node_modules/bare-buffer/lib/constants.js
var require_constants = __commonJS({
"../../node_modules/bare-buffer/lib/constants.js"(exports, module) {
var binding = require_binding();
module.exports = binding.constants;
}
});
// ../../node_modules/bare-buffer/lib/ascii.js
var require_ascii = __commonJS({
"../../node_modules/bare-buffer/lib/ascii.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return string.length;
};
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
const offset = buffer.byteOffset + start;
const len = end - start;
if (binding.validateAscii(buffer.buffer, offset, len)) {
return binding.toStringLatin1(buffer.buffer, offset, len);
}
let result = "";
for (let i = start; i < end; i++) {
result += String.fromCharCode(buffer[i] & 127);
}
return result;
};
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
return binding.writeLatin1(buffer.buffer, buffer.byteOffset + start, end - start, string);
};
exports.validate = function validate(buffer) {
return binding.validateAscii(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
}
});
// ../../node_modules/bare-buffer/lib/base64.js
var require_base64 = __commonJS({
"../../node_modules/bare-buffer/lib/base64.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
let len = string.length;
if (string.charCodeAt(len - 1) === 61) len--;
if (len > 1 && string.charCodeAt(len - 1) === 61) len--;
return len * 3 >>> 2;
};
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
return binding.toStringBase64(buffer.buffer, buffer.byteOffset + start, end - start);
};
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
return binding.writeBase64(buffer.buffer, buffer.byteOffset + start, end - start, string);
};
}
});
// ../../node_modules/bare-buffer/lib/base64url.js
var require_base64url = __commonJS({
"../../node_modules/bare-buffer/lib/base64url.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
let len = string.length;
if (string.charCodeAt(len - 1) === 61) len--;
if (len > 1 && string.charCodeAt(len - 1) === 61) len--;
return len * 3 >>> 2;
};
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
return binding.toStringBase64URL(buffer.buffer, buffer.byteOffset + start, end - start);
};
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
return binding.writeBase64(buffer.buffer, buffer.byteOffset + start, end - start, string);
};
}
});
// ../../node_modules/bare-buffer/lib/hex.js
var require_hex = __commonJS({
"../../node_modules/bare-buffer/lib/hex.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return string.length >>> 1;
};
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
return binding.toStringHex(buffer.buffer, buffer.byteOffset + start, end - start);
};
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
return binding.writeHex(buffer.buffer, buffer.byteOffset + start, end - start, string);
};
}
});
// ../../node_modules/bare-buffer/lib/utf8.js
var require_utf8 = __commonJS({
"../../node_modules/bare-buffer/lib/utf8.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return binding.byteLengthUTF8(string);
};
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
return binding.toStringUTF8(buffer.buffer, buffer.byteOffset + start, end - start);
};
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
return binding.writeUTF8(buffer.buffer, buffer.byteOffset + start, end - start, string);
};
exports.validate = function validate(buffer) {
return binding.validateUTF8(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
}
});
// ../../node_modules/bare-buffer/lib/utf16le.js
var require_utf16le = __commonJS({
"../../node_modules/bare-buffer/lib/utf16le.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return string.length * 2;
};
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
return binding.toStringUTF16LE(buffer.buffer, buffer.byteOffset + start, end - start);
};
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
return binding.writeUTF16LE(buffer.buffer, buffer.byteOffset + start, end - start, string);
};
}
});
// ../../node_modules/bare-buffer/lib/latin1.js
var require_latin1 = __commonJS({
"../../node_modules/bare-buffer/lib/latin1.js"(exports) {
var binding = require_binding();
exports.byteLength = function byteLength(string) {
return string.length;
};
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
return binding.toStringLatin1(buffer.buffer, buffer.byteOffset + start, end - start);
};
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
return binding.writeLatin1(buffer.buffer, buffer.byteOffset + start, end - start, string);
};
}
});
// ../../node_modules/bare-buffer/index.js
var require_bare_buffer = __commonJS({
"../../node_modules/bare-buffer/index.js"(exports, module) {
var constants = require_constants();
var ascii = require_ascii();
var base64 = require_base64();
var base64url = require_base64url();
var hex = require_hex();
var utf8 = require_utf8();
var utf16le = require_utf16le();
var latin1 = require_latin1();
var binding = require_binding();
var kind = Symbol.for("bare.buffer.kind");
var SWAP_MIN_LENGTH = 128;
var poolSize = 65536;
var pool = null;
var poolLength = 0;
var poolOffset = 0;
var Buffer2 = class _Buffer extends Uint8Array {
static get [kind]() {
return 0;
}
static get poolSize() {
return poolSize;
}
static set poolSize(value) {
poolSize = Math.max(0, value);
}
constructor(arrayBuffer, offset, length, opts = {}) {
if (typeof arrayBuffer === "number") {
opts = offset || {};
const { uninitialized = false } = opts;
offset = 0;
length = arrayBuffer;
if (Number.isNaN(length) || length < 0 || length > constants.MAX_LENGTH) {
throw new RangeError(`Buffer length must be between 0 and ${constants.MAX_LENGTH}`);
}
arrayBuffer = uninitialized ? binding.allocUnsafe(length) : binding.alloc(length);
} else {
if (length > constants.MAX_LENGTH) {
throw new RangeError(`Buffer length must be at most ${constants.MAX_LENGTH}`);
}
if (typeof offset === "object" && offset !== null) {
opts = offset;
offset = 0;
length = arrayBuffer.byteLength;
} else if (typeof length === "object" && length !== null) {
opts = length;
length = arrayBuffer.byteLength - offset;
}
}
super(arrayBuffer, offset, length);
}
get [kind]() {
return _Buffer[kind];
}
copy(target, targetStart = 0, sourceStart = 0, sourceEnd = this.byteLength) {
const source = this;
if (targetStart < 0) targetStart = 0;
if (targetStart >= target.byteLength) return 0;
const targetLength = target.byteLength - targetStart;
if (sourceStart < 0) sourceStart = 0;
if (sourceStart >= source.byteLength) return 0;
if (sourceEnd <= sourceStart) return 0;
if (sourceEnd > source.byteLength) sourceEnd = source.byteLength;
if (sourceEnd - sourceStart > targetLength) {
sourceEnd = sourceStart + targetLength;
}
const sourceLength = sourceEnd - sourceStart;
if (source === target) {
target.copyWithin(targetStart, sourceStart, sourceEnd);
} else if (sourceStart === 0 && sourceEnd === source.byteLength) {
target.set(source, targetStart);
} else {
target.set(
new Uint8Array(source.buffer, source.byteOffset + sourceStart, sourceLength),
targetStart
);
}
return sourceLength;
}
equals(target) {
const source = this;
if (source === target) return true;
if (source.byteLength !== target.byteLength) return false;
return binding.compare(
source.buffer,
source.byteOffset,
source.byteLength,
target.buffer,
target.byteOffset,
target.byteLength
) === 0;
}
compare(target, targetStart = 0, targetEnd = target.byteLength, sourceStart = 0, sourceEnd = this.byteLength) {
const source = this;
if (source === target) return 0;
if (arguments.length === 1) {
targetStart = 0;
targetEnd = target.byteLength;
sourceStart = 0;
sourceEnd = source.byteLength;
} else {
if (targetStart < 0) targetStart = 0;
if (targetStart > target.byteLength) targetStart = target.byteLength;
if (targetEnd < targetStart) targetEnd = targetStart;
if (targetEnd > target.byteLength) targetEnd = target.byteLength;
if (sourceStart < 0) sourceStart = 0;
if (sourceStart > source.byteLength) sourceStart = source.byteLength;
if (sourceEnd < sourceStart) sourceEnd = sourceStart;
if (sourceEnd > source.byteLength) sourceEnd = source.byteLength;
}
return binding.compare(
source.buffer,
source.byteOffset + sourceStart,
sourceEnd - sourceStart,
target.buffer,
target.byteOffset + targetStart,
targetEnd - targetStart
);
}
fill(value, offset = 0, end = this.byteLength, encoding = "utf8") {
if (typeof value === "string") {
if (typeof offset === "string") {
encoding = offset;
offset = 0;
end = this.byteLength;
} else if (typeof end === "string") {
encoding = end;
end = this.byteLength;
}
} else if (typeof value === "number") {
value = value & 255;
} else if (typeof value === "boolean") {
value = +value;
}
if (offset < 0) offset = 0;
if (offset >= this.byteLength) return this;
if (end <= offset) return this;
if (end > this.byteLength) end = this.byteLength;
if (typeof value === "number") return super.fill(value, offset, end);
if (typeof value === "string") value = exports.from(value, encoding);
const length = value.byteLength;
if (length === 0) return super.fill(0, offset, end);
if (length === 1) return super.fill(value[0], offset, end);
return fillPattern(this, value, length, offset, end);
}
includes(value, offset, encoding) {
return this.indexOf(value, offset, encoding) !== -1;
}
indexOf(value, offset = 0, encoding) {
if (typeof value === "boolean") value = +value;
if (typeof value === "number") {
return super.indexOf(value & 255, offset);
}
return bidirectionalIndexOf(
this,
value,
offset,
encoding,
true
/* first */
);
}
lastIndexOf(value, offset = this.byteLength - 1, encoding) {
if (typeof value === "boolean") value = +value;
if (typeof value === "number") {
return super.lastIndexOf(value & 255, offset);
}
return bidirectionalIndexOf(
this,
value,
offset,
encoding,
false
/* last */
);
}
swap16() {
const length = this.byteLength;
if (length % 2 !== 0) {
throw new RangeError("Buffer size must be a multiple of 16-bits");
}
if (length < SWAP_MIN_LENGTH) {
for (let i = 0; i < length; i += 2) swap(this, i, i + 1);
} else {
binding.swap16(this.buffer, this.byteOffset, length);
}
return this;
}
swap32() {
const length = this.byteLength;
if (length % 4 !== 0) {
throw new RangeError("Buffer size must be a multiple of 32-bits");
}
if (length < SWAP_MIN_LENGTH) {
for (let i = 0; i < length; i += 4) {
swap(this, i, i + 3);
swap(this, i + 1, i + 2);
}
} else {
binding.swap32(this.buffer, this.byteOffset, length);
}
return this;
}
swap64() {
const length = this.byteLength;
if (length % 8 !== 0) {
throw new RangeError("Buffer size must be a multiple of 64-bits");
}
if (length < SWAP_MIN_LENGTH) {
for (let i = 0; i < length; i += 8) {
swap(this, i, i + 7);
swap(this, i + 1, i + 6);
swap(this, i + 2, i + 5);
swap(this, i + 3, i + 4);
}
} else {
binding.swap64(this.buffer, this.byteOffset, length);
}
return this;
}
toString(encoding = "utf8", start = 0, end = this.byteLength) {
if (arguments.length === 0) return utf8.toString(this);
if (arguments.length === 1) return codecFor(encoding).toString(this);
if (start < 0) start = 0;
if (start >= this.byteLength) return "";
if (end <= start) return "";
if (end > this.byteLength) end = this.byteLength;
return codecFor(encoding).toString(this, start, end);
}
toJSON() {
const length = this.byteLength;
const data = new Array(length);
for (let i = 0; i < length; i++) data[i] = this[i];
return data;
}
write(string, offset = 0, length = this.byteLength - offset, encoding = "utf8") {
if (arguments.length === 1) return utf8.write(this, string);
if (typeof offset === "string") {
encoding = offset;
offset = 0;
length = this.byteLength;
} else if (typeof length === "string") {
encoding = length;
length = this.byteLength - offset;
}
length = Math.min(length, exports.byteLength(string, encoding));
let start = offset;
if (start < 0) start = 0;
if (start >= this.byteLength) return 0;
let end = offset + length;
if (end <= start) return 0;
if (end > this.byteLength) end = this.byteLength;
return codecFor(encoding).write(this, string, start, end);
}
readBigInt64BE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
return viewOf(this).getBigInt64(offset, false);
}
readBigInt64LE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
return viewOf(this).getBigInt64(offset, true);
}
readBigUint64BE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
return viewOf(this).getBigUint64(offset, false);
}
readBigUint64LE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
return viewOf(this).getBigUint64(offset, true);
}
readDoubleBE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
return viewOf(this).getFloat64(offset, false);
}
readDoubleLE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
return viewOf(this).getFloat64(offset, true);
}
readFloatBE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
return viewOf(this).getFloat32(offset, false);
}
readFloatLE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
return viewOf(this).getFloat32(offset, true);
}
readInt8(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const value = this[offset];
if (value === void 0) boundsError();
return value << 24 >> 24;
}
readInt16BE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const first = this[offset];
const last = this[offset + 1];
if (first === void 0 || last === void 0) boundsError();
return (first << 8 | last) << 16 >> 16;
}
readInt16LE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const first = this[offset];
const last = this[offset + 1];
if (first === void 0 || last === void 0) boundsError();
return (last << 8 | first) << 16 >> 16;
}
readInt32BE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const first = this[offset];
const last = this[offset + 3];
if (first === void 0 || last === void 0) boundsError();
return first << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | last;
}
readInt32LE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const first = this[offset];
const last = this[offset + 3];
if (first === void 0 || last === void 0) boundsError();
return first | this[offset + 1] << 8 | this[offset + 2] << 16 | last << 24;
}
readIntBE(offset, byteLength) {
if (!Number.isInteger(offset)) offsetError(offset);
if (byteLength === 6) return readInt48BE(this, offset);
if (byteLength === 5) return readInt40BE(this, offset);
if (byteLength === 3) return readInt24BE(this, offset);
if (byteLength === 4) return this.readInt32BE(offset);
if (byteLength === 2) return this.readInt16BE(offset);
if (byteLength === 1) return this.readInt8(offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
readIntLE(offset, byteLength) {
if (!Number.isInteger(offset)) offsetError(offset);
if (byteLength === 6) return readInt48LE(this, offset);
if (byteLength === 5) return readInt40LE(this, offset);
if (byteLength === 3) return readInt24LE(this, offset);
if (byteLength === 4) return this.readInt32LE(offset);
if (byteLength === 2) return this.readInt16LE(offset);
if (byteLength === 1) return this.readInt8(offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
readUint8(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const value = this[offset];
if (value === void 0) boundsError();
return value;
}
readUint16BE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const first = this[offset];
const last = this[offset + 1];
if (first === void 0 || last === void 0) boundsError();
return first << 8 | last;
}
readUint16LE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const first = this[offset];
const last = this[offset + 1];
if (first === void 0 || last === void 0) boundsError();
return last << 8 | first;
}
readUint32BE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const first = this[offset];
const last = this[offset + 3];
if (first === void 0 || last === void 0) boundsError();
return first * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | last);
}
readUint32LE(offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
const first = this[offset];
const last = this[offset + 3];
if (first === void 0 || last === void 0) boundsError();
return last * 16777216 + (this[offset + 2] << 16 | this[offset + 1] << 8 | first);
}
readUintBE(offset, byteLength) {
if (!Number.isInteger(offset)) offsetError(offset);
if (byteLength === 6) return readUint48BE(this, offset);
if (byteLength === 5) return readUint40BE(this, offset);
if (byteLength === 3) return readUint24BE(this, offset);
if (byteLength === 4) return this.readUint32BE(offset);
if (byteLength === 2) return this.readUint16BE(offset);
if (byteLength === 1) return this.readUint8(offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
readUintLE(offset, byteLength) {
if (!Number.isInteger(offset)) offsetError(offset);
if (byteLength === 6) return readUint48LE(this, offset);
if (byteLength === 5) return readUint40LE(this, offset);
if (byteLength === 3) return readUint24LE(this, offset);
if (byteLength === 4) return this.readUint32LE(offset);
if (byteLength === 2) return this.readUint16LE(offset);
if (byteLength === 1) return this.readUint8(offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
writeBigInt64BE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
viewOf(this).setBigInt64(offset, value, false);
return offset + 8;
}
writeBigInt64LE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
viewOf(this).setBigInt64(offset, value, true);
return offset + 8;
}
writeBigUint64BE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
viewOf(this).setBigUint64(offset, value, false);
return offset + 8;
}
writeBigUint64LE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
viewOf(this).setBigUint64(offset, value, true);
return offset + 8;
}
writeDoubleBE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
viewOf(this).setFloat64(offset, value, false);
return offset + 8;
}
writeDoubleLE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
viewOf(this).setFloat64(offset, value, true);
return offset + 8;
}
writeFloatBE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
viewOf(this).setFloat32(offset, value, false);
return offset + 4;
}
writeFloatLE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
viewOf(this).setFloat32(offset, value, true);
return offset + 4;
}
writeInt8(value, offset = 0) {
return this.writeUint8(value, offset);
}
writeInt16BE(value, offset = 0) {
return this.writeUint16BE(value, offset);
}
writeInt16LE(value, offset = 0) {
return this.writeUint16LE(value, offset);
}
writeInt32BE(value, offset = 0) {
return this.writeUint32BE(value, offset);
}
writeInt32LE(value, offset = 0) {
return this.writeUint32LE(value, offset);
}
writeIntBE(value, offset, byteLength) {
if (!Number.isInteger(offset)) offsetError(offset);
if (byteLength === 6) return writeInt48BE(this, value, offset);
if (byteLength === 5) return writeInt40BE(this, value, offset);
if (byteLength === 3) return writeInt24BE(this, value, offset);
if (byteLength === 4) return this.writeInt32BE(value, offset);
if (byteLength === 2) return this.writeInt16BE(value, offset);
if (byteLength === 1) return this.writeInt8(value, offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
writeIntLE(value, offset, byteLength) {
if (!Number.isInteger(offset)) offsetError(offset);
if (byteLength === 6) return writeInt48LE(this, value, offset);
if (byteLength === 5) return writeInt40LE(this, value, offset);
if (byteLength === 3) return writeInt24LE(this, value, offset);
if (byteLength === 4) return this.writeInt32LE(value, offset);
if (byteLength === 2) return this.writeInt16LE(value, offset);
if (byteLength === 1) return this.writeInt8(value, offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
writeUint8(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
if (this[offset] === void 0) boundsError();
this[offset] = value;
return offset + 1;
}
writeUint16BE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
if (this[offset] === void 0 || this[offset + 1] === void 0) boundsError();
this[offset] = value >>> 8;
this[offset + 1] = value;
return offset + 2;
}
writeUint16LE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
if (this[offset] === void 0 || this[offset + 1] === void 0) boundsError();
this[offset] = value;
this[offset + 1] = value >>> 8;
return offset + 2;
}
writeUint32LE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
if (this[offset] === void 0 || this[offset + 3] === void 0) boundsError();
this[offset] = value;
this[offset + 1] = value >>> 8;
this[offset + 2] = value >>> 16;
this[offset + 3] = value >>> 24;
return offset + 4;
}
writeUint32BE(value, offset = 0) {
if (!Number.isInteger(offset)) offsetError(offset);
if (this[offset] === void 0 || this[offset + 3] === void 0) boundsError();
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value;
return offset + 4;
}
writeUintBE(value, offset, byteLength) {
if (!Number.isInteger(offset)) offsetError(offset);
if (byteLength === 6) return writeUint48BE(this, value, offset);
if (byteLength === 5) return writeUint40BE(this, value, offset);
if (byteLength === 3) return writeUint24BE(this, value, offset);
if (byteLength === 4) return this.writeUint32BE(value, offset);
if (byteLength === 2) return this.writeUint16BE(value, offset);
if (byteLength === 1) return this.writeUint8(value, offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
writeUintLE(value, offset, byteLength) {
if (!Number.isInteger(offset)) offsetError(offset);
if (byteLength === 6) return writeUint48LE(this, value, offset);
if (byteLength === 5) return writeUint40LE(this, value, offset);
if (byteLength === 3) return writeUint24LE(this, value, offset);
if (byteLength === 4) return this.writeUint32LE(value, offset);
if (byteLength === 2) return this.writeUint16LE(value, offset);
if (byteLength === 1) return this.writeUint8(value, offset);
throw new RangeError(`Byte length must be between 1 and 6`);
}
};
for (const [alias, name] of [
["readBigUInt64BE", "readBigUint64BE"],
["readBigUInt64LE", "readBigUint64LE"],
["readUInt8", "readUint8"],
["readUInt16BE", "readUint16BE"],
["readUInt16LE", "readUint16LE"],
["readUInt32BE", "readUint32BE"],
["readUInt32LE", "readUint32LE"],
["readUIntBE", "readUintBE"],
["readUIntLE", "readUintLE"],
["writeBigUInt64BE", "writeBigUint64BE"],
["writeBigUInt64LE", "writeBigUint64LE"],
["writeUInt8", "writeUint8"],
["writeUInt16BE", "writeUint16BE"],
["writeUInt16LE", "writeUint16LE"],
["writeUInt32BE", "writeUint32BE"],
["writeUInt32LE", "writeUint32LE"],
["writeUIntBE", "writeUintBE"],
["writeUIntLE", "writeUintLE"]
]) {
Object.defineProperty(Buffer2.prototype, alias, {
value: Buffer2.prototype[name],
writable: true,
configurable: true
});
}
module.exports = exports = Buffer2;
exports.Buffer = Buffer2;
exports.constants = constants;
var codecs = /* @__PURE__ */ Object.create(null);
codecs.ascii = ascii;
codecs.base64 = base64;
codecs.base64url = base64url;
codecs.hex = hex;
codecs.utf8 = codecs["utf-8"] = utf8;
codecs.utf16le = codecs.ucs2 = codecs["utf-16le"] = codecs["ucs-2"] = utf16le;
codecs.latin1 = codecs.binary = latin1;
function codecFor(encoding) {
if (encoding === void 0) return utf8;
let codec = codecs[encoding];
if (codec !== void 0) return codec;
codec = codecs[encoding.toLowerCase()];
if (codec !== void 0) return codec;
throw new Error(`Unknown encoding '${encoding}'`);
}
var views = /* @__PURE__ */ new WeakMap();
function viewOf(buffer) {
let view = views.get(buffer);
if (view === void 0) {
view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
views.set(buffer, view);
}
return view;
}
exports.isBuffer = function isBuffer(value) {
if (value instanceof Buffer2) return true;
return typeof value === "object" && value !== null && value[kind] === Buffer2[kind];
};
exports.isEncoding = function isEncoding(encoding) {
try {
codecFor(encoding);
return true;
} catch {
return false;
}
};
exports.isASCII = function isASCII(buffer) {
return ascii.validate(buffer);
};
exports.isAscii = exports.isASCII;
exports.isUTF8 = function isUTF8(buffer) {
return utf8.validate(buffer);
};
exports.isUtf8 = exports.isUTF8;
exports.alloc = function alloc(size, fill, encoding) {
if (fill !== void 0 && fill !== 0) {
const buffer = new Buffer2(size, { uninitialized: true });
return buffer.fill(fill, 0, buffer.byteLength, encoding);
}
return new Buffer2(size);
};
exports.allocUnsafe = function allocUnsafe(size) {
return allocate(size);
};
exports.allocUnsafeSlow = function allocUnsafeSlow(size) {
return new Buffer2(size, { uninitialized: true });
};
exports.byteLength = function byteLength(string, encoding) {
if (typeof string === "string") {
return codecFor(encoding).byteLength(string);
}
return string.byteLength;
};
exports.compare = function compare(a, b) {
return binding.compare(a.buffer, a.byteOffset, a.byteLength, b.buffer, b.byteOffset, b.byteLength);
};
exports.concat = function concat(buffers, length) {
const n = buffers.length;
if (length === void 0) {
length = 0;
for (let i = 0; i < n; i++) length += buffers[i].byteLength;
}
const result = allocate(length);
let offset = 0;
for (let i = 0; i < n; i++) {
const buffer = buffers[i];
if (offset + buffer.byteLength > length) {
result.set(new Uint8Array(buffer.buffer, buffer.byteOffset, length - offset), offset);
return result;
}
result.set(buffer, offset);
offset += buffer.byteLength;
}
if (offset < length) result.fill(0, offset, length);
return result;
};
exports.coerce = function coerce(buffer) {
if (exports.isBuffer(buffer)) return buffer;
return new Buffer2(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
exports.copyBytesFrom = function copyBytesFrom(view, offset = 0, length = view.length - offset) {
if (offset + length > view.length) {
throw new RangeError("View length is out of range");
}
if (offset !== 0 || length !== view.length) {
view = view.subarray(offset, offset + length);
}
return new Buffer2(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
};
exports.from = function from(value, encodingOrOffset, length) {
if (typeof value === "string") return fromString(value, encodingOrOffset);
if (Array.isArray(value)) return fromArray(value);
if (ArrayBuffer.isView(value)) return fromBuffer(value);
return fromArrayBuffer(value, encodingOrOffset, length);
};
function fromString(string, encoding) {
const codec = codecFor(encoding);
const length = codec.byteLength(string);
const buffer = allocate(length);
const written = codec.write(buffer, string, 0, length);
if (written < length) return buffer.subarray(0, written);
return buffer;
}
function fromArray(array) {
const buffer = allocate(array.length);
buffer.set(array);
return buffer;
}
function fromBuffer(buffer) {
const copy = allocate(buffer.byteLength);
copy.set(buffer);
return copy;
}
function fromArrayBuffer(arrayBuffer, offset, length) {
return new Buffer2(arrayBuffer, offset, length);
}
function bidirectionalIndexOf(buffer, value, offset, encoding, first) {
if (buffer.byteLength === 0) return -1;
if (typeof offset === "string") {
encoding = offset;
offset = 0;
} else if (offset === void 0) {
offset = first ? 0 : buffer.byteLength - 1;
} else if (offset < 0) {
offset += buffer.byteLength;
}
if (offset >= buffer.byteLength) {
if (first) return -1;
else offset = buffer.byteLength - 1;
} else if (offset < 0) {
if (first) offset = 0;
else return -1;
}
if (typeof value === "string") value = exports.from(value, encoding);
const needleLength = value.byteLength;
if (needleLength === 0) return -1;
const length = buffer.byteLength;
const last = length - needleLength;
if (first) {
if (offset > last) return -1;
} else {
if (offset > last) offset = last;
if (offset < 0) return -1;
}
let j = 0;
while (j < needleLength && buffer[offset + j] === value[j]) j++;
if (j === needleLength) return offset;
if (first) {
if (offset === last) return -1;
return binding.indexOf(
buffer.buffer,
buffer.byteOffset,
length,
value.buffer,
value.byteOffset,
needleLength,
offset + 1
);
}
if (offset === 0) return -1;
return binding.lastIndexOf(
buffer.buffer,
buffer.byteOffset,
length,
value.buffer,
value.byteOffset,
needleLength,
offset - 1
);
}
function fillPattern(buffer, value, length, offset, end) {
const n = end - offset;
if (n < 64) {
for (let i = 0; i < n; i++) buffer[offset + i] = value[i % length];
return buffer;
}
let filled = length < n ? length : n;
for (let i = 0; i < filled; i++) buffer[offset + i] = value[i];
while (filled < n) {
const copy = filled < n - filled ? filled : n - filled;
buffer.copyWithin(offset + filled, offset, offset + copy);
filled += copy;
}
return buffer;
}
function allocate(size) {
if (Number.isNaN(size) || size <= 0 || size >= poolSize >>> 1) {
return new Buffer2(size, { uninitialized: true });
}
if (pool === null || poolLength !== poolSize || poolLength - poolOffset < size) {
pool = binding.allocUnsafe(poolSize);
poolLength = poolSize;
poolOffset = 0;
}
const buffer = new Buffer2(pool, poolOffset, size);
poolOffset = poolOffset + size + 7 & ~7;
return buffer;
}
function swap(buffer, n, m) {
const i = buffer[n];
buffer[n] = buffer[m];
buffer[m] = i;
}
exports.atob = function atob(data) {
return Buffer2.from(data, "base64").toString("latin1");
};
exports.btoa = function btoa(data) {
if (typeof data !== "string") data = String(data);
return Buffer2.from(data, "latin1").toString("base64");
};
exports.transcode = function transcode(buffer, from, to) {
return Buffer2.from(buffer.toString(from), to);
};
function boundsError() {
throw new RangeError("Offset is outside the bounds of the buffer");
}
function offsetError(offset) {
if (typeof offset !== "number") {
throw new TypeError(`Offset must be a number, received type ${typeof offset}`);
}
throw new RangeError("Offset is outside the bounds of the buffer");
}
function readInt48BE(buffer, offset) {
const value = readUint48BE(buffer, offset);
return value >= 140737488355328 ? value - 281474976710656 : value;
}
function readInt48LE(buffer, offset) {
const value = readUint48LE(buffer, offset);
return value >= 140737488355328 ? value - 281474976710656 : value;
}
function readInt40BE(buffer, offset) {
const value = readUint40BE(buffer, offset);
return value >= 549755813888 ? value - 1099511627776 : value;
}
function readInt40LE(buffer, offset) {
const value = readUint40LE(buffer, offset);
return value >= 549755813888 ? value - 1099511627776 : value;
}
function readInt24BE(buffer, offset) {
const value = readUint24BE(buffer, offset);
return value & 8388608 ? value - 16777216 : value;
}
function readInt24LE(buffer, offset) {
const value = readUint24LE(buffer, offset);
return value & 8388608 ? value - 16777216 : value;
}
function readUint48BE(buffer, offset) {
const first = buffer[offset];
const last = buffer[offset + 5];
if (first === void 0 || last === void 0) boundsError();
return (first * 256 + buffer[offset + 1]) * 4294967296 + (buffer[offset + 2] << 24 >>> 0) + (buffer[offset + 3] << 16) + (buffer[offset + 4] << 8) + last;
}
function readUint48LE(buffer, offset) {
const first = buffer[offset];
const last = buffer[offset + 5];
if (first === void 0 || last === void 0) boundsError();
return (buffer[offset + 4] + last * 256) * 4294967296 + (buffer[offset + 3] << 24 >>> 0) + (buffer[offset + 2] << 16) + (buffer[offset + 1] << 8) + first;
}
function readUint40BE(buffer, offset) {
const first = buffer[offset];
const last = buffer[offset + 4];
if (first === void 0 || last === void 0) boundsError();
return first * 4294967296 + (buffer[offset + 1] << 24 >>> 0) + (buffer[offset + 2] << 16) + (buffer[offset + 3] << 8) + last;
}
function readUint40LE(buffer, offset) {
const first = buffer[offset];
const last = buffer[offset + 4];
if (first === void 0 || last === void 0) boundsError();
return last * 4294967296 + (buffer[offset + 3] << 24 >>> 0) + (buffer[offset + 2] << 16) + (buffer[offset + 1] << 8) + first;
}
function readUint24BE(buffer, offset) {
const first = buffer[offset];
const last = buffer[offset + 2];
if (first === void 0 || last === void 0) boundsError();
return first << 16 | buffer[offset + 1] << 8 | last;
}
function readUint24LE(buffer, offset) {
const first = buffer[offset];
const last = buffer[offset + 2];
if (first === void 0 || last === void 0) boundsError();
return last << 16 | buffer[offset + 1] << 8 | first;
}
function writeInt48BE(buffer, value, offset) {
if (value < 0) value += 281474976710656;
return writeUint48BE(buffer, value, offset);
}
function writeInt48LE(buffer, value, offset) {
if (value < 0) value += 281474976710656;
return writeUint48LE(buffer, value, offset);
}
function writeInt40BE(buffer, value, offset) {
if (value < 0) value += 1099511627776;
return writeUint40BE(buffer, value, offset);
}
function writeInt40LE(buffer, value, offset) {
if (value < 0) value += 1099511627776;
return writeUint40LE(buffer, value, offset);
}
function writeInt24BE(buffer, value, offset) {
if (value < 0) value += 16777216;
return writeUint24BE(buffer, value, offset);
}
function writeInt24LE(buffer, value, offset) {
if (value < 0) value += 16777216;
return writeUint24LE(buffer, value, offset);
}
function writeUint48BE(buffer, value, offset) {
if (buffer[offset] === void 0 || buffer[offset + 5] === void 0) boundsError();
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
buffer[offset] = hi >>> 8;
buffer[offset + 1] = hi;
buffer[offset + 2] = lo >>> 24;
buffer[offset + 3] = lo >>> 16;
buffer[offset + 4] = lo >>> 8;
buffer[offset + 5] = lo;
return offset + 6;
}
function writeUint48LE(buffer, value, offset) {
if (buffer[offset] === void 0 || buffer[offset + 5] === void 0) boundsError();
const hi = Math.floor(value / 4294967296);
const lo = value >>> 0;
buffer[offset] = lo;
buffer[offset + 1] = lo >>> 8;
buffer[offset + 2] = lo >>> 16;
buffer[offset + 3] = lo >>> 24;
buffer[offset + 4] = hi;
buffer[offset + 5] = hi >>> 8;
return offset + 6;
}
function writeUint40BE(buffer, value, offset) {
if (buffer[offset] === void 0 || buffer[offset + 4] === void 0) boundsError();
const lo = value >>> 0;
buffer[offset] = Math.floor(value / 4294967296);
buffer[offset + 1] = lo >>> 24;
buffer[offset + 2] = lo >>> 16;
buffer[offset + 3] = lo >>> 8;
buffer[offset + 4] = lo;
return offset + 5;
}
function writeUint40LE(buffer, value, offset) {
if (buffer[offset] === void 0 || buffer[offset + 4] === void 0) boundsError();
const lo = value >>> 0;
buffer[offset] = lo;
buffer[offset + 1] = lo >>> 8;
buffer[offset + 2] = lo >>> 16;
buffer[offset + 3] = lo >>> 24;
buffer[offset + 4] = Math.floor(value / 4294967296);
return offset + 5;
}
function writeUint24BE(buffer, value, offset) {
if (buffer[offset] === void 0 || buffer[offset + 2] === void 0) boundsError();
buffer[offset] = value >>> 16;
buffer[offset + 1] = value >>> 8;
buffer[offset + 2] = value;
return offset + 3;
}
function writeUint24LE(buffer, value, offset) {
if (buffer[offset] === void 0 || buffer[offset + 2] === void 0) boundsError();
buffer[offset] = value;
buffer[offset + 1] = value >>> 8;
buffer[offset + 2] = value >>> 16;
return offset + 3;
}
}
});
// ../../bare-lib-entry-bareBuffer.js
var bare_lib_entry_bareBuffer_exports = {};
__export(bare_lib_entry_bareBuffer_exports, {
default: () => bare_lib_entry_bareBuffer_default
});
var import_bare_buffer = __toESM(require_bare_buffer());
var bare_lib_entry_bareBuffer_default = import_bare_buffer.default;
return __toCommonJS(bare_lib_entry_bareBuffer_exports);
})();
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["bareBuffer"]=v;})();
Reference in New Issue View Git Blame Copy Permalink