zeed 1.2.2 → 1.3.0

package/dist/common/bin/lib0/encoding.d.mts

@@ -0,0 +1,178 @@
+//#region src/common/bin/lib0/encoding.d.ts
+/**
+ * Original at https://github.com/dmonad/lib0
+ *
+ * Efficient schema-less binary encoding with support for variable length encoding.
+ *
+ * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
+ *
+ * Encodes numbers in little-endian order (least to most significant byte order)
+ * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+ * which is also used in Protocol Buffers.
+ *
+ * ```js
+ * // encoding step
+ * const encoder = new encoding.createEncoder()
+ * encoding.writeVarUint(encoder, 256)
+ * encoding.writeVarString(encoder, 'Hello world!')
+ * const buf = encoding.toUint8Array(encoder)
+ * ```
+ *
+ * ```js
+ * // decoding step
+ * const decoder = new decoding.createDecoder(buf)
+ * decoding.readVarUint(decoder) // => 256
+ * decoding.readVarString(decoder) // => 'Hello world!'
+ * decoding.hasContent(decoder) // => false - all data is read
+ * ```
+ */
+/**
+ * A BinaryEncoder handles the encoding to an Uint8Array.
+ */
+declare class BinEncoder {
+  cpos: number;
+  cbuf: Uint8Array;
+  bufs: Uint8Array[];
+  constructor();
+}
+declare function createBinEncoder(): BinEncoder;
+/**
+ * The current length of the encoded data.
+ */
+declare function length(encoder: BinEncoder): number;
+/**
+ * Transform to Uint8Array.
+ */
+declare function encodeToUint8Array(encoder: BinEncoder): Uint8Array;
+/**
+ * Verify that it is possible to write `len` bytes wtihout checking. If
+ * necessary, a new Buffer with the required length is attached.
+ */
+declare function verifyLen(encoder: BinEncoder, len: number): void;
+/**
+ * Write one byte to the encoder.
+ */
+declare function write(encoder: BinEncoder, num: number): void;
+/**
+ * Write one byte at a specific position.
+ * Position must already be written (i.e. encoder.length > pos)
+ */
+declare function set(encoder: BinEncoder, pos: number, num: number): void;
+/**
+ * Write one byte as an unsigned integer.
+ */
+declare const writeUint8: typeof write;
+/**
+ * Write one byte as an unsigned Integer at a specific location.
+ */
+declare const setUint8: typeof set;
+/**
+ * Write two bytes as an unsigned integer.
+ */
+declare function writeUint16(encoder: BinEncoder, num: number): void;
+/**
+ * Write two bytes as an unsigned integer at a specific location.
+ */
+declare function setUint16(encoder: BinEncoder, pos: number, num: number): void;
+/**
+ * Write two bytes as an unsigned integer
+ */
+declare function writeUint32(encoder: BinEncoder, num: number): void;
+/**
+ * Write two bytes as an unsigned integer in big endian order.
+ * (most significant byte first)
+ */
+declare function writeUint32BigEndian(encoder: BinEncoder, num: number): void;
+/**
+ * Write two bytes as an unsigned integer at a specific location.
+ */
+declare function setUint32(encoder: BinEncoder, pos: number, num: number): void;
+/**
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
+ */
+declare function writeVarUint(encoder: BinEncoder, num: number): void;
+declare function isNegativeZero(n: number): boolean;
+/**
+ * Write a variable length integer.
+ *
+ * We use the 7th bit instead for signaling that this is a negative number.
+ */
+declare function writeVarInt(encoder: BinEncoder, num: number): void;
+/**
+ * Append fixed-length Uint8Array to the encoder.
+ */
+declare function writeUint8Array(encoder: BinEncoder, uint8Array: Uint8Array): void;
+/**
+ * Append an Uint8Array to BinEncoder.
+ */
+declare function writeVarUint8Array(encoder: BinEncoder, uint8Array: Uint8Array): void;
+/**
+ * Write a variable length string.
+ */
+declare function writeVarString(encoder: BinEncoder, str: string): void;
+/**
+ * Write the content of another Encoder.
+ *
+ * @TODO: can be improved!
+ *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.
+ *                Encoders start with a rather big initial buffer.
+ */
+declare function writeBinaryEncoder(encoder: BinEncoder, append: BinEncoder): void;
+/**
+ * Create an DataView of the next `len` bytes. Use it to write data after
+ * calling this function.
+ *
+ * ```js
+ * // write float32 using DataView
+ * const dv = writeOnDataView(encoder, 4)
+ * dv.setFloat32(0, 1.1)
+ * // read float32 using DataView
+ * const dv = readFromDataView(encoder, 4)
+ * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)
+ * ```
+ */
+declare function writeOnDataView(encoder: BinEncoder, len: number): DataView;
+declare function writeFloat32(encoder: BinEncoder, num: number): void;
+declare function writeFloat64(encoder: BinEncoder, num: number): void;
+declare function writeBigInt64(encoder: BinEncoder, num: bigint): void;
+declare function writeBigUint64(encoder: BinEncoder, num: bigint): void;
+/**
+ * Encode data with efficient binary format.
+ *
+ * Differences to JSON:
+ * • Transforms data to a binary format (not to a string)
+ * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)
+ * • Numbers are efficiently encoded either as a variable length integer, as a
+ *   32 bit float, as a 64 bit float, or as a 64 bit bigint.
+ *
+ * Encoding table:
+ *
+ * | Data Type           | Prefix   | Encoding Method    | Comment |
+ * | ------------------- | -------- | ------------------ | ------- |
+ * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |
+ * | null                | 126      |                    | |
+ * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |
+ * | float32             | 124      | writeFloat32       | |
+ * | float64             | 123      | writeFloat64       | |
+ * | bigint              | 122      | writeBigInt64      | |
+ * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |
+ * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |
+ * | string              | 119      | writeVarString     | |
+ * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |
+ * | array<any>          | 117      | custom             | Writes {length} then {length} json values |
+ * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |
+ *
+ * Reasons for the decreasing prefix:
+ * We need the first bit for extendability (later we may want to encode the
+ * prefix with writeVarUint). The remaining 7 bits are divided as follows:
+ * [0-30]   the beginning of the data range is used for custom purposes
+ *          (defined by the function that uses this library)
+ * [31-127] the end of the data range is used for data encoding by
+ *          lib0/encoding.js
+ */
+declare function writeAny(encoder: BinEncoder, data: undefined | null | number | bigint | boolean | string | {
+  [s: string]: any;
+} | Array<any> | Uint8Array): void;
+//#endregion
+export { BinEncoder, createBinEncoder, encodeToUint8Array, isNegativeZero, length, set, setUint16, setUint32, setUint8, verifyLen, write, writeAny, writeBigInt64, writeBigUint64, writeBinaryEncoder, writeFloat32, writeFloat64, writeOnDataView, writeUint16, writeUint32, writeUint32BigEndian, writeUint8, writeUint8Array, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array };
+//# sourceMappingURL=encoding.d.mts.map

package/dist/common/bin/lib0/encoding.mjs

@@ -0,0 +1,2 @@
+import"./binary.mjs";import{createUint8ArrayViewFromArrayBuffer as e}from"./create.mjs";import{encodeUtf8 as t,getUtf8TextEncoder as n}from"./string.mjs";var r=class{cpos;cbuf;bufs;constructor(){this.cpos=0,this.cbuf=new Uint8Array(100),this.bufs=[]}};function i(){return new r}function a(e){let t=e.cpos;for(let n=0;n<e.bufs.length;n++)t+=e.bufs[n].length;return t}function o(t){let n=new Uint8Array(a(t)),r=0;for(let e=0;e<t.bufs.length;e++){let i=t.bufs[e];n.set(i,r),r+=i.length}return n.set(e(t.cbuf.buffer,0,t.cpos),r),n}function s(t,n){let r=t.cbuf.length;r-t.cpos<n&&(t.bufs.push(e(t.cbuf.buffer,0,t.cpos)),t.cbuf=new Uint8Array(Math.max(r,n)*2),t.cpos=0)}function c(e,t){let n=e.cbuf.length;e.cpos===n&&(e.bufs.push(e.cbuf),e.cbuf=new Uint8Array(n*2),e.cpos=0),e.cbuf[e.cpos++]=t}function l(e,t,n){let r=null;for(let n=0;n<e.bufs.length&&r===null;n++){let i=e.bufs[n];t<i.length?r=i:t-=i.length}r===null&&(r=e.cbuf),r[t]=n}const u=c,d=l;function f(e,t){c(e,t&255),c(e,t>>>8&255)}function p(e,t,n){l(e,t,n&255),l(e,t+1,n>>>8&255)}function m(e,t){for(let n=0;n<4;n++)c(e,t&255),t>>>=8}function h(e,t){for(let n=3;n>=0;n--)c(e,t>>>8*n&255)}function g(e,t,n){for(let r=0;r<4;r++)l(e,t+r,n&255),n>>>=8}function _(e,t){for(;t>127;)c(e,128|127&t),t=Math.floor(t/128);c(e,127&t)}function v(e){return e===0?1/e<0:e<0}function y(e,t){let n=v(t);for(n&&(t=-t),c(e,(t>63?128:0)|(n?64:0)|63&t),t=Math.floor(t/64);t>0;)c(e,(t>127?128:0)|127&t),t=Math.floor(t/128)}function b(e,t){let n=e.cbuf.length,r=e.cpos,i=Math.min(n-r,t.length),a=t.length-i;e.cbuf.set(t.subarray(0,i),r),e.cpos+=i,a>0&&(e.bufs.push(e.cbuf),e.cbuf=new Uint8Array(Math.max(n*2,a)),e.cbuf.set(t.subarray(i)),e.cpos=a)}function x(e,t){_(e,t.byteLength),b(e,t)}let S,C;function w(e,r){if(S??(S=new Uint8Array(3e4),C=S.length/3),r.length<C){let t=n().encodeInto(r,S).written||0;_(e,t);for(let n=0;n<t;n++)c(e,S[n])}else x(e,t(r))}function T(e,t){let n=unescape(encodeURIComponent(t)),r=n.length;_(e,r);for(let t=0;t<r;t++)c(e,n.codePointAt(t))}function E(e,t){return n()?.encodeInto?w(e,t):T(e,t)}function D(e,t){return b(e,o(t))}function O(e,t){s(e,t);let n=new DataView(e.cbuf.buffer,e.cpos,t);return e.cpos+=t,n}function k(e,t){return O(e,4).setFloat32(0,t,!1)}function A(e,t){return O(e,8).setFloat64(0,t,!1)}function j(e,t){return O(e,8).setBigInt64(0,t,!1)}function M(e,t){return O(e,8).setBigUint64(0,t,!1)}let N;function P(e){return N??=new DataView(new ArrayBuffer(4)),N.setFloat32(0,e),N.getFloat32(0)===e}function F(e,t){switch(typeof t){case`string`:c(e,119),E(e,t);break;case`number`:Number.isInteger(t)&&Math.abs(t)<=2147483647?(c(e,125),y(e,t)):P(t)?(c(e,124),k(e,t)):(c(e,123),A(e,t));break;case`bigint`:c(e,122),j(e,t);break;case`object`:if(t===null)c(e,126);else if(Array.isArray(t)){c(e,117),_(e,t.length);for(let n=0;n<t.length;n++)F(e,t[n])}else if(t instanceof Uint8Array)c(e,116),x(e,t);else{c(e,118);let n=Object.keys(t);n.sort(),_(e,n.length);for(let r=0;r<n.length;r++){let i=n[r];E(e,i),F(e,t[i])}}break;case`boolean`:c(e,t?120:121);break;default:c(e,127)}}export{r as BinEncoder,i as createBinEncoder,o as encodeToUint8Array,v as isNegativeZero,a as length,l as set,p as setUint16,g as setUint32,d as setUint8,s as verifyLen,c as write,F as writeAny,j as writeBigInt64,M as writeBigUint64,D as writeBinaryEncoder,k as writeFloat32,A as writeFloat64,O as writeOnDataView,f as writeUint16,m as writeUint32,h as writeUint32BigEndian,u as writeUint8,b as writeUint8Array,y as writeVarInt,E as writeVarString,_ as writeVarUint,x as writeVarUint8Array};
+//# sourceMappingURL=encoding.mjs.map

package/dist/common/bin/lib0/encoding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.mjs","names":[],"sources":["../../../../src/common/bin/lib0/encoding.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Efficient schema-less binary encoding with support for variable length encoding.\n *\n * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.\n *\n * Encodes numbers in little-endian order (least to most significant byte order)\n * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)\n * which is also used in Protocol Buffers.\n *\n * ```js\n * // encoding step\n * const encoder = new encoding.createEncoder()\n * encoding.writeVarUint(encoder, 256)\n * encoding.writeVarString(encoder, 'Hello world!')\n * const buf = encoding.toUint8Array(encoder)\n * ```\n *\n * ```js\n * // decoding step\n * const decoder = new decoding.createDecoder(buf)\n * decoding.readVarUint(decoder) // => 256\n * decoding.readVarString(decoder) // => 'Hello world!'\n * decoding.hasContent(decoder) // => false - all data is read\n * ```\n */\n\nimport { BIT7, BIT8, BITS6, BITS7, BITS8, BITS31 } from './binary'\nimport { createUint8ArrayViewFromArrayBuffer } from './create'\nimport { encodeUtf8, getUtf8TextEncoder } from './string'\n\n/**\n * A BinaryEncoder handles the encoding to an Uint8Array.\n */\nexport class BinEncoder {\n  cpos: number\n  cbuf: Uint8Array\n  bufs: Uint8Array[]\n\n  constructor() {\n    this.cpos = 0\n    this.cbuf = new Uint8Array(100)\n    this.bufs = []\n  }\n}\n\nexport function createBinEncoder(): BinEncoder {\n  return new BinEncoder()\n}\n\n/**\n * The current length of the encoded data.\n */\nexport function length(encoder: BinEncoder): number {\n  let len = encoder.cpos\n  for (let i = 0; i < encoder.bufs.length; i++)\n    len += encoder.bufs[i].length\n\n  return len\n}\n\n/**\n * Transform to Uint8Array.\n */\nexport function encodeToUint8Array(encoder: BinEncoder): Uint8Array {\n  const uint8arr = new Uint8Array(length(encoder))\n  let curPos = 0\n  for (let i = 0; i < encoder.bufs.length; i++) {\n    const d = encoder.bufs[i]\n    uint8arr.set(d, curPos)\n    curPos += d.length\n  }\n  uint8arr.set(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos), curPos)\n  return uint8arr\n}\n\n/**\n * Verify that it is possible to write `len` bytes wtihout checking. If\n * necessary, a new Buffer with the required length is attached.\n */\nexport function verifyLen(encoder: BinEncoder, len: number) {\n  const bufferLen = encoder.cbuf.length\n  if (bufferLen - encoder.cpos < len) {\n    encoder.bufs.push(createUint8ArrayViewFromArrayBuffer(encoder.cbuf.buffer, 0, encoder.cpos))\n    encoder.cbuf = new Uint8Array(Math.max(bufferLen, len) * 2)\n    encoder.cpos = 0\n  }\n}\n\n/**\n * Write one byte to the encoder.\n */\nexport function write(encoder: BinEncoder, num: number) {\n  const bufferLen = encoder.cbuf.length\n  if (encoder.cpos === bufferLen) {\n    encoder.bufs.push(encoder.cbuf)\n    encoder.cbuf = new Uint8Array(bufferLen * 2)\n    encoder.cpos = 0\n  }\n  encoder.cbuf[encoder.cpos++] = num\n}\n\n/**\n * Write one byte at a specific position.\n * Position must already be written (i.e. encoder.length > pos)\n */\nexport function set(encoder: BinEncoder, pos: number, num: number) {\n  let buffer = null\n  // iterate all buffers and adjust position\n  for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {\n    const b = encoder.bufs[i]\n    if (pos < b.length)\n      buffer = b // found buffer\n\n    else\n      pos -= b.length\n  }\n  if (buffer === null) {\n    // use current buffer\n    buffer = encoder.cbuf\n  }\n  buffer[pos] = num\n}\n\n/**\n * Write one byte as an unsigned integer.\n */\nexport const writeUint8 = write\n\n/**\n * Write one byte as an unsigned Integer at a specific location.\n */\nexport const setUint8 = set\n\n/**\n * Write two bytes as an unsigned integer.\n */\nexport function writeUint16(encoder: BinEncoder, num: number) {\n  write(encoder, num & BITS8)\n  write(encoder, (num >>> 8) & BITS8)\n}\n/**\n * Write two bytes as an unsigned integer at a specific location.\n */\nexport function setUint16(encoder: BinEncoder, pos: number, num: number) {\n  set(encoder, pos, num & BITS8)\n  set(encoder, pos + 1, (num >>> 8) & BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer\n */\nexport function writeUint32(encoder: BinEncoder, num: number) {\n  for (let i = 0; i < 4; i++) {\n    write(encoder, num & BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write two bytes as an unsigned integer in big endian order.\n * (most significant byte first)\n */\nexport function writeUint32BigEndian(encoder: BinEncoder, num: number) {\n  for (let i = 3; i >= 0; i--)\n    write(encoder, (num >>> (8 * i)) & BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer at a specific location.\n */\nexport function setUint32(encoder: BinEncoder, pos: number, num: number) {\n  for (let i = 0; i < 4; i++) {\n    set(encoder, pos + i, num & BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write a variable length unsigned integer. Max encodable integer is 2^53.\n */\nexport function writeVarUint(encoder: BinEncoder, num: number) {\n  while (num > BITS7) {\n    write(encoder, BIT8 | (BITS7 & num))\n    num = Math.floor(num / 128) // shift >>> 7\n  }\n  write(encoder, BITS7 & num)\n}\n\nexport function isNegativeZero(n: number) {\n  return n !== 0 ? n < 0 : 1 / n < 0\n}\n\n/**\n * Write a variable length integer.\n *\n * We use the 7th bit instead for signaling that this is a negative number.\n */\nexport function writeVarInt(encoder: BinEncoder, num: number) {\n  const isNegative = isNegativeZero(num)\n  if (isNegative)\n    num = -num\n\n  //             |- whether to continue reading         |- whether is negative     |- number\n  write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | (BITS6 & num))\n  num = Math.floor(num / 64) // shift >>> 6\n\n  // We don't need to consider the case of num === 0 so we can use a different\n  // pattern here than above.\n  while (num > 0) {\n    write(encoder, (num > BITS7 ? BIT8 : 0) | (BITS7 & num))\n    num = Math.floor(num / 128) // shift >>> 7\n  }\n}\n\n/**\n * Append fixed-length Uint8Array to the encoder.\n */\nexport function writeUint8Array(encoder: BinEncoder, uint8Array: Uint8Array) {\n  const bufferLen = encoder.cbuf.length\n  const cpos = encoder.cpos\n  const leftCopyLen = Math.min(bufferLen - cpos, uint8Array.length)\n  const rightCopyLen = uint8Array.length - leftCopyLen\n  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos)\n  encoder.cpos += leftCopyLen\n  if (rightCopyLen > 0) {\n    // Still something to write, write right half..\n    // Append new buffer\n    encoder.bufs.push(encoder.cbuf)\n    // must have at least size of remaining buffer\n    encoder.cbuf = new Uint8Array(Math.max(bufferLen * 2, rightCopyLen))\n    // copy array\n    encoder.cbuf.set(uint8Array.subarray(leftCopyLen))\n    encoder.cpos = rightCopyLen\n  }\n}\n\n/**\n * Append an Uint8Array to BinEncoder.\n */\nexport function writeVarUint8Array(encoder: BinEncoder, uint8Array: Uint8Array): void {\n  writeVarUint(encoder, uint8Array.byteLength)\n  writeUint8Array(encoder, uint8Array)\n}\n\n/**\n * A cache to store strings temporarily\n */\nlet _strBuffer: Uint8Array\nlet _maxStrBSize: number\n\n/**\n * Write a variable length string.\n */\nfunction _writeVarStringNative(encoder: BinEncoder, str: string) {\n  if (_strBuffer == null) {\n    _strBuffer = new Uint8Array(30000)\n    _maxStrBSize = _strBuffer.length / 3\n  }\n\n  if (str.length < _maxStrBSize) {\n    // We can encode the string into the existing buffer\n    const written = getUtf8TextEncoder()!.encodeInto(str, _strBuffer).written || 0\n    writeVarUint(encoder, written)\n    for (let i = 0; i < written; i++)\n      write(encoder, _strBuffer[i])\n  }\n  else {\n    writeVarUint8Array(encoder, encodeUtf8(str))\n  }\n}\n\n/**\n * Write a variable length string.\n */\nfunction _writeVarStringPolyfill(encoder: BinEncoder, str: string) {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  writeVarUint(encoder, len)\n  for (let i = 0; i < len; i++)\n    write(encoder, (encodedString.codePointAt(i) as number))\n}\n\n/**\n * Write a variable length string.\n */\nexport function writeVarString(encoder: BinEncoder, str: string) {\n  return getUtf8TextEncoder()?.encodeInto\n    ? _writeVarStringNative(encoder, str)\n    : _writeVarStringPolyfill(encoder, str)\n}\n\n/**\n * Write the content of another Encoder.\n *\n * @TODO: can be improved!\n *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.\n *                Encoders start with a rather big initial buffer.\n */\nexport function writeBinaryEncoder(encoder: BinEncoder, append: BinEncoder) {\n  return writeUint8Array(encoder, encodeToUint8Array(append))\n}\n\n/**\n * Create an DataView of the next `len` bytes. Use it to write data after\n * calling this function.\n *\n * ```js\n * // write float32 using DataView\n * const dv = writeOnDataView(encoder, 4)\n * dv.setFloat32(0, 1.1)\n * // read float32 using DataView\n * const dv = readFromDataView(encoder, 4)\n * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)\n * ```\n */\nexport function writeOnDataView(encoder: BinEncoder, len: number): DataView {\n  verifyLen(encoder, len)\n  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len)\n  encoder.cpos += len\n  return dview\n}\n\nexport function writeFloat32(encoder: BinEncoder, num: number) {\n  return writeOnDataView(encoder, 4).setFloat32(0, num, false)\n}\n\nexport function writeFloat64(encoder: BinEncoder, num: number) {\n  return writeOnDataView(encoder, 8).setFloat64(0, num, false)\n}\n\nexport function writeBigInt64(encoder: BinEncoder, num: bigint) {\n  return (writeOnDataView(encoder, 8)).setBigInt64(0, num, false)\n}\n\nexport function writeBigUint64(encoder: BinEncoder, num: bigint) {\n  return (writeOnDataView(encoder, 8)).setBigUint64(0, num, false)\n}\n\nlet floatTestBed: DataView\n\n/**\n * Check if a number can be encoded as a 32 bit float.\n */\nfunction isFloat32(num: number): boolean {\n  floatTestBed ??= new DataView(new ArrayBuffer(4))\n  floatTestBed.setFloat32(0, num)\n  return floatTestBed.getFloat32(0) === num\n}\n\n/**\n * Encode data with efficient binary format.\n *\n * Differences to JSON:\n * • Transforms data to a binary format (not to a string)\n * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)\n * • Numbers are efficiently encoded either as a variable length integer, as a\n *   32 bit float, as a 64 bit float, or as a 64 bit bigint.\n *\n * Encoding table:\n *\n * | Data Type           | Prefix   | Encoding Method    | Comment |\n * | ------------------- | -------- | ------------------ | ------- |\n * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |\n * | null                | 126      |                    | |\n * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |\n * | float32             | 124      | writeFloat32       | |\n * | float64             | 123      | writeFloat64       | |\n * | bigint              | 122      | writeBigInt64      | |\n * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |\n * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |\n * | string              | 119      | writeVarString     | |\n * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |\n * | array<any>          | 117      | custom             | Writes {length} then {length} json values |\n * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |\n *\n * Reasons for the decreasing prefix:\n * We need the first bit for extendability (later we may want to encode the\n * prefix with writeVarUint). The remaining 7 bits are divided as follows:\n * [0-30]   the beginning of the data range is used for custom purposes\n *          (defined by the function that uses this library)\n * [31-127] the end of the data range is used for data encoding by\n *          lib0/encoding.js\n */\nexport function writeAny(encoder: BinEncoder, data: undefined | null | number | bigint | boolean | string | { [s: string]: any } | Array<any> | Uint8Array) {\n  switch (typeof data) {\n    case 'string':\n      // TYPE 119: STRING\n      write(encoder, 119)\n      writeVarString(encoder, data)\n      break\n    case 'number':\n      if (Number.isInteger(data) && Math.abs(data) <= BITS31) {\n        // TYPE 125: INTEGER\n        write(encoder, 125)\n        writeVarInt(encoder, data)\n      }\n      else if (isFloat32(data)) {\n        // TYPE 124: FLOAT32\n        write(encoder, 124)\n        writeFloat32(encoder, data)\n      }\n      else {\n        // TYPE 123: FLOAT64\n        write(encoder, 123)\n        writeFloat64(encoder, data)\n      }\n      break\n    case 'bigint':\n      // TYPE 122: BigInt\n      write(encoder, 122)\n      writeBigInt64(encoder, data)\n      break\n    case 'object':\n      if (data === null) {\n        // TYPE 126: null\n        write(encoder, 126)\n      }\n      else if (Array.isArray(data)) {\n        // TYPE 117: Array\n        write(encoder, 117)\n        writeVarUint(encoder, data.length)\n        for (let i = 0; i < data.length; i++)\n          writeAny(encoder, data[i])\n      }\n      else if (data instanceof Uint8Array) {\n        // TYPE 116: ArrayBuffer\n        write(encoder, 116)\n        writeVarUint8Array(encoder, data)\n      }\n      else {\n        // TYPE 118: Object\n        write(encoder, 118)\n        const keys = Object.keys(data)\n        keys.sort() // guarantee comparability and consistency\n        writeVarUint(encoder, keys.length)\n        for (let i = 0; i < keys.length; i++) {\n          const key = keys[i]\n          writeVarString(encoder, key)\n          writeAny(encoder, data[key])\n        }\n      }\n      break\n    case 'boolean':\n      // TYPE 120/121: boolean (true/false)\n      write(encoder, data ? 120 : 121)\n      break\n    default:\n      // TYPE 127: undefined\n      write(encoder, 127)\n  }\n}\n"],"mappings":"0JAmCA,IAAa,EAAb,KAAwB,CACtB,KACA,KACA,KAEA,aAAc,CACZ,KAAK,KAAO,EACZ,KAAK,KAAO,IAAI,WAAW,IAAI,CAC/B,KAAK,KAAO,EAAE,GAIlB,SAAgB,GAA+B,CAC7C,OAAO,IAAI,EAMb,SAAgB,EAAO,EAA6B,CAClD,IAAI,EAAM,EAAQ,KAClB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,KAAK,OAAQ,IACvC,GAAO,EAAQ,KAAK,GAAG,OAEzB,OAAO,EAMT,SAAgB,EAAmB,EAAiC,CAClE,IAAM,EAAW,IAAI,WAAW,EAAO,EAAQ,CAAC,CAC5C,EAAS,EACb,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,KAAK,OAAQ,IAAK,CAC5C,IAAM,EAAI,EAAQ,KAAK,GACvB,EAAS,IAAI,EAAG,EAAO,CACvB,GAAU,EAAE,OAGd,OADA,EAAS,IAAI,EAAoC,EAAQ,KAAK,OAAQ,EAAG,EAAQ,KAAK,CAAE,EAAO,CACxF,EAOT,SAAgB,EAAU,EAAqB,EAAa,CAC1D,IAAM,EAAY,EAAQ,KAAK,OAC3B,EAAY,EAAQ,KAAO,IAC7B,EAAQ,KAAK,KAAK,EAAoC,EAAQ,KAAK,OAAQ,EAAG,EAAQ,KAAK,CAAC,CAC5F,EAAQ,KAAO,IAAI,WAAW,KAAK,IAAI,EAAW,EAAI,CAAG,EAAE,CAC3D,EAAQ,KAAO,GAOnB,SAAgB,EAAM,EAAqB,EAAa,CACtD,IAAM,EAAY,EAAQ,KAAK,OAC3B,EAAQ,OAAS,IACnB,EAAQ,KAAK,KAAK,EAAQ,KAAK,CAC/B,EAAQ,KAAO,IAAI,WAAW,EAAY,EAAE,CAC5C,EAAQ,KAAO,GAEjB,EAAQ,KAAK,EAAQ,QAAU,EAOjC,SAAgB,EAAI,EAAqB,EAAa,EAAa,CACjE,IAAI,EAAS,KAEb,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,KAAK,QAAU,IAAW,KAAM,IAAK,CAC/D,IAAM,EAAI,EAAQ,KAAK,GACnB,EAAM,EAAE,OACV,EAAS,EAGT,GAAO,EAAE,OAET,IAAW,OAEb,EAAS,EAAQ,MAEnB,EAAO,GAAO,EAMhB,MAAa,EAAa,EAKb,EAAW,EAKxB,SAAgB,EAAY,EAAqB,EAAa,CAC5D,EAAM,EAAS,EAAA,IAAY,CAC3B,EAAM,EAAU,IAAQ,EAAA,IAAW,CAKrC,SAAgB,EAAU,EAAqB,EAAa,EAAa,CACvE,EAAI,EAAS,EAAK,EAAA,IAAY,CAC9B,EAAI,EAAS,EAAM,EAAI,IAAQ,EAAA,IAAW,CAM5C,SAAgB,EAAY,EAAqB,EAAa,CAC5D,IAAK,IAAI,EAAI,EAAG,EAAI,EAAG,IACrB,EAAM,EAAS,EAAA,IAAY,CAC3B,KAAS,EAQb,SAAgB,EAAqB,EAAqB,EAAa,CACrE,IAAK,IAAI,EAAI,EAAG,GAAK,EAAG,IACtB,EAAM,EAAU,IAAS,EAAI,EAAA,IAAY,CAM7C,SAAgB,EAAU,EAAqB,EAAa,EAAa,CACvE,IAAK,IAAI,EAAI,EAAG,EAAI,EAAG,IACrB,EAAI,EAAS,EAAM,EAAG,EAAA,IAAY,CAClC,KAAS,EAOb,SAAgB,EAAa,EAAqB,EAAa,CAC7D,KAAO,EAAA,KACL,EAAM,EAAA,IAAA,IAAyB,EAAK,CACpC,EAAM,KAAK,MAAM,EAAM,IAAI,CAE7B,EAAM,EAAA,IAAiB,EAAI,CAG7B,SAAgB,EAAe,EAAW,CACxC,OAAO,IAAM,EAAY,EAAI,EAAI,EAAhB,EAAI,EAQvB,SAAgB,EAAY,EAAqB,EAAa,CAC5D,IAAM,EAAa,EAAe,EAAI,CAUtC,IATI,IACF,EAAM,CAAC,GAGT,EAAM,GAAU,EAAA,GAAA,IAAqB,IAAM,EAAA,GAAoB,GAAA,GAAc,EAAK,CAClF,EAAM,KAAK,MAAM,EAAM,GAAG,CAInB,EAAM,GACX,EAAM,GAAU,EAAA,IAAA,IAAqB,GAAA,IAAc,EAAK,CACxD,EAAM,KAAK,MAAM,EAAM,IAAI,CAO/B,SAAgB,EAAgB,EAAqB,EAAwB,CAC3E,IAAM,EAAY,EAAQ,KAAK,OACzB,EAAO,EAAQ,KACf,EAAc,KAAK,IAAI,EAAY,EAAM,EAAW,OAAO,CAC3D,EAAe,EAAW,OAAS,EACzC,EAAQ,KAAK,IAAI,EAAW,SAAS,EAAG,EAAY,CAAE,EAAK,CAC3D,EAAQ,MAAQ,EACZ,EAAe,IAGjB,EAAQ,KAAK,KAAK,EAAQ,KAAK,CAE/B,EAAQ,KAAO,IAAI,WAAW,KAAK,IAAI,EAAY,EAAG,EAAa,CAAC,CAEpE,EAAQ,KAAK,IAAI,EAAW,SAAS,EAAY,CAAC,CAClD,EAAQ,KAAO,GAOnB,SAAgB,EAAmB,EAAqB,EAA8B,CACpF,EAAa,EAAS,EAAW,WAAW,CAC5C,EAAgB,EAAS,EAAW,CAMtC,IAAI,EACA,EAKJ,SAAS,EAAsB,EAAqB,EAAa,CAM/D,GALI,IACF,EAAa,IAAI,WAAW,IAAM,CAClC,EAAe,EAAW,OAAS,GAGjC,EAAI,OAAS,EAAc,CAE7B,IAAM,EAAU,GAAoB,CAAE,WAAW,EAAK,EAAW,CAAC,SAAW,EAC7E,EAAa,EAAS,EAAQ,CAC9B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAS,IAC3B,EAAM,EAAS,EAAW,GAAG,MAG/B,EAAmB,EAAS,EAAW,EAAI,CAAC,CAOhD,SAAS,EAAwB,EAAqB,EAAa,CACjE,IAAM,EAAgB,SAAS,mBAAmB,EAAI,CAAC,CACjD,EAAM,EAAc,OAC1B,EAAa,EAAS,EAAI,CAC1B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,IACvB,EAAM,EAAU,EAAc,YAAY,EAAE,CAAY,CAM5D,SAAgB,EAAe,EAAqB,EAAa,CAC/D,OAAO,GAAoB,EAAE,WACzB,EAAsB,EAAS,EAAI,CACnC,EAAwB,EAAS,EAAI,CAU3C,SAAgB,EAAmB,EAAqB,EAAoB,CAC1E,OAAO,EAAgB,EAAS,EAAmB,EAAO,CAAC,CAgB7D,SAAgB,EAAgB,EAAqB,EAAuB,CAC1E,EAAU,EAAS,EAAI,CACvB,IAAM,EAAQ,IAAI,SAAS,EAAQ,KAAK,OAAQ,EAAQ,KAAM,EAAI,CAElE,MADA,GAAQ,MAAQ,EACT,EAGT,SAAgB,EAAa,EAAqB,EAAa,CAC7D,OAAO,EAAgB,EAAS,EAAE,CAAC,WAAW,EAAG,EAAK,GAAM,CAG9D,SAAgB,EAAa,EAAqB,EAAa,CAC7D,OAAO,EAAgB,EAAS,EAAE,CAAC,WAAW,EAAG,EAAK,GAAM,CAG9D,SAAgB,EAAc,EAAqB,EAAa,CAC9D,OAAQ,EAAgB,EAAS,EAAE,CAAE,YAAY,EAAG,EAAK,GAAM,CAGjE,SAAgB,EAAe,EAAqB,EAAa,CAC/D,OAAQ,EAAgB,EAAS,EAAE,CAAE,aAAa,EAAG,EAAK,GAAM,CAGlE,IAAI,EAKJ,SAAS,EAAU,EAAsB,CAGvC,MAFA,KAAiB,IAAI,SAAS,IAAI,YAAY,EAAE,CAAC,CACjD,EAAa,WAAW,EAAG,EAAI,CACxB,EAAa,WAAW,EAAE,GAAK,EAqCxC,SAAgB,EAAS,EAAqB,EAA8G,CAC1J,OAAQ,OAAO,EAAf,CACE,IAAK,SAEH,EAAM,EAAS,IAAI,CACnB,EAAe,EAAS,EAAK,CAC7B,MACF,IAAK,SACC,OAAO,UAAU,EAAK,EAAI,KAAK,IAAI,EAAK,EAAA,YAE1C,EAAM,EAAS,IAAI,CACnB,EAAY,EAAS,EAAK,EAEnB,EAAU,EAAK,EAEtB,EAAM,EAAS,IAAI,CACnB,EAAa,EAAS,EAAK,GAI3B,EAAM,EAAS,IAAI,CACnB,EAAa,EAAS,EAAK,EAE7B,MACF,IAAK,SAEH,EAAM,EAAS,IAAI,CACnB,EAAc,EAAS,EAAK,CAC5B,MACF,IAAK,SACH,GAAI,IAAS,KAEX,EAAM,EAAS,IAAI,SAEZ,MAAM,QAAQ,EAAK,CAAE,CAE5B,EAAM,EAAS,IAAI,CACnB,EAAa,EAAS,EAAK,OAAO,CAClC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAC/B,EAAS,EAAS,EAAK,GAAG,SAErB,aAAgB,WAEvB,EAAM,EAAS,IAAI,CACnB,EAAmB,EAAS,EAAK,KAE9B,CAEH,EAAM,EAAS,IAAI,CACnB,IAAM,EAAO,OAAO,KAAK,EAAK,CAC9B,EAAK,MAAM,CACX,EAAa,EAAS,EAAK,OAAO,CAClC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAAK,CACpC,IAAM,EAAM,EAAK,GACjB,EAAe,EAAS,EAAI,CAC5B,EAAS,EAAS,EAAK,GAAK,EAGhC,MACF,IAAK,UAEH,EAAM,EAAS,EAAO,IAAM,IAAI,CAChC,MACF,QAEE,EAAM,EAAS,IAAI"}

package/dist/common/bin/lib0/string.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJJKWFF7Bcjs = require('../../../chunk-JJKWFF7B.cjs');require('../../../chunk-P7XCQ7WV.cjs');exports._encodeUtf8Polyfill = _chunkJJKWFF7Bcjs.d; exports.decodeUtf8 = _chunkJJKWFF7Bcjs.h; exports.encodeUtf8 = _chunkJJKWFF7Bcjs.f; exports.fromCamelCase = _chunkJJKWFF7Bcjs.b; exports.getUtf8TextDecoder = _chunkJJKWFF7Bcjs.g; exports.getUtf8TextEncoder = _chunkJJKWFF7Bcjs.e; exports.splice = _chunkJJKWFF7Bcjs.i; exports.trimLeft = _chunkJJKWFF7Bcjs.a; exports.utf8ByteLength = _chunkJJKWFF7Bcjs.c;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return e.toLowerCase()}const t=/^\s*/g;function n(e){return e.replace(t,``)}const r=/([A-Z])/g;function i(t,i){return n(t.replace(r,t=>`${i}${e(t)}`))}function a(e){return unescape(encodeURIComponent(e)).length}function o(e){let t=unescape(encodeURIComponent(e)),n=t.length,r=new Uint8Array(n);for(let e=0;e<n;e++)r[e]=t.codePointAt(e);return r}let s;function c(){return s===void 0&&(s=typeof TextEncoder<`u`?new TextEncoder:null),s}function l(e){return c()?s.encode(e):o(e)}function u(e){let t=e.length,n=``,r=0;for(;t>0;){let i=t<1e4?t:1e4,a=e.subarray(r,r+i);r+=i,n+=String.fromCodePoint(...a),t-=i}return decodeURIComponent(escape(n))}let d;function f(){return d===void 0&&(d=(typeof TextDecoder>`u`?null:new TextDecoder(`utf-8`,{fatal:!0,ignoreBOM:!0}))??null,d&&d.decode(new Uint8Array).length===1&&(d=null)),d}function p(e){return f()?d.decode(e):u(e)}function m(e,t,n,r=``){return e.slice(0,t)+r+e.slice(t+n)}exports._encodeUtf8Polyfill=o,exports.decodeUtf8=p,exports.encodeUtf8=l,exports.fromCamelCase=i,exports.getUtf8TextDecoder=f,exports.getUtf8TextEncoder=c,exports.splice=m,exports.trimLeft=n,exports.utf8ByteLength=a;
 //# sourceMappingURL=string.cjs.map

package/dist/common/bin/lib0/string.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/bin/lib0/string.cjs"],"names":[],"mappings":"AAAA,wIAA0D,uCAAoC,mZAAkL","file":"/Users/dirk/work/github-zeed/dist/common/bin/lib0/string.cjs"}
+{"version":3,"file":"string.cjs","names":[],"sources":["../../../../src/common/bin/lib0/string.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility module to work with strings.\n */\n\n// export const fromCharCode = String.fromCharCode\n// export const fromCodePoint = String.fromCodePoint\n\nfunction toLowerCase(s: string): string {\n  return s.toLowerCase()\n}\n\nconst trimLeftRegex = /^\\s*/g\n\nexport function trimLeft(s: string): string {\n  return s.replace(trimLeftRegex, '')\n}\n\nconst fromCamelCaseRegex = /([A-Z])/g\n\nexport function fromCamelCase(s: string, separator: string): string {\n  return trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`))\n}\n\n/**\n * Compute the utf8ByteLength\n */\nexport function utf8ByteLength(str: string): number {\n  return unescape(encodeURIComponent(str)).length\n}\n\nexport function _encodeUtf8Polyfill(str: string): Uint8Array {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  const buf = new Uint8Array(len)\n  for (let i = 0; i < len; i++)\n    buf[i] = (encodedString.codePointAt(i) as number)\n\n  return buf\n}\n\nlet utf8TextEncoder: TextEncoder | undefined | null\n\nexport function getUtf8TextEncoder(): TextEncoder | null {\n  if (utf8TextEncoder === undefined)\n    utf8TextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null)\n  return utf8TextEncoder\n}\n\nexport function encodeUtf8(str: string): Uint8Array {\n  return getUtf8TextEncoder()\n    ? utf8TextEncoder!.encode(str)\n    : _encodeUtf8Polyfill(str)\n}\n\nfunction _decodeUtf8Polyfill(buf: Uint8Array): string {\n  let remainingLen = buf.length\n  let encodedString = ''\n  let bufPos = 0\n  while (remainingLen > 0) {\n    const nextLen = remainingLen < 10000 ? remainingLen : 10000\n    const bytes = buf.subarray(bufPos, bufPos + nextLen)\n    bufPos += nextLen\n    // Starting with ES5.1 we can supply a generic array-like object as arguments\n    encodedString += String.fromCodePoint(...bytes as any)\n    remainingLen -= nextLen\n  }\n  return decodeURIComponent(escape(encodedString))\n}\n\nlet utf8TextDecoder: any\n\nexport function getUtf8TextDecoder(): TextDecoder | undefined {\n  if (utf8TextDecoder === undefined) {\n    utf8TextDecoder = (typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })) ?? null\n    if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {\n      // Safari doesn't handle BOM correctly.\n      // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.\n      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and\n      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call\n      // Another issue is that from then on no BOM chars are recognized anymore\n      utf8TextDecoder = null\n    }\n  }\n  return utf8TextDecoder\n}\n\nexport function decodeUtf8(buf: Uint8Array): string {\n  return getUtf8TextDecoder()\n    ? utf8TextDecoder.decode(buf)\n    : _decodeUtf8Polyfill(buf)\n}\n\nexport function splice(str: string, index: number, remove: number, insert = '') {\n  return str.slice(0, index) + insert + str.slice(index + remove)\n}\n"],"mappings":"mEASA,SAAS,EAAY,EAAmB,CACtC,OAAO,EAAE,aAAa,CAGxB,MAAM,EAAgB,QAEtB,SAAgB,EAAS,EAAmB,CAC1C,OAAO,EAAE,QAAQ,EAAe,GAAG,CAGrC,MAAM,EAAqB,WAE3B,SAAgB,EAAc,EAAW,EAA2B,CAClE,OAAO,EAAS,EAAE,QAAQ,EAAoB,GAAS,GAAG,IAAY,EAAY,EAAM,GAAG,CAAC,CAM9F,SAAgB,EAAe,EAAqB,CAClD,OAAO,SAAS,mBAAmB,EAAI,CAAC,CAAC,OAG3C,SAAgB,EAAoB,EAAyB,CAC3D,IAAM,EAAgB,SAAS,mBAAmB,EAAI,CAAC,CACjD,EAAM,EAAc,OACpB,EAAM,IAAI,WAAW,EAAI,CAC/B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,IACvB,EAAI,GAAM,EAAc,YAAY,EAAE,CAExC,OAAO,EAGT,IAAI,EAEJ,SAAgB,GAAyC,CAGvD,OAFI,IAAoB,IAAA,KACtB,EAAmB,OAAO,YAAgB,IAAc,IAAI,YAAgB,MACvE,EAGT,SAAgB,EAAW,EAAyB,CAClD,OAAO,GAAoB,CACvB,EAAiB,OAAO,EAAI,CAC5B,EAAoB,EAAI,CAG9B,SAAS,EAAoB,EAAyB,CACpD,IAAI,EAAe,EAAI,OACnB,EAAgB,GAChB,EAAS,EACb,KAAO,EAAe,GAAG,CACvB,IAAM,EAAU,EAAe,IAAQ,EAAe,IAChD,EAAQ,EAAI,SAAS,EAAQ,EAAS,EAAQ,CACpD,GAAU,EAEV,GAAiB,OAAO,cAAc,GAAG,EAAa,CACtD,GAAgB,EAElB,OAAO,mBAAmB,OAAO,EAAc,CAAC,CAGlD,IAAI,EAEJ,SAAgB,GAA8C,CAY5D,OAXI,IAAoB,IAAA,KACtB,GAAmB,OAAO,YAAgB,IAAc,KAAO,IAAI,YAAY,QAAS,CAAE,MAAO,GAAM,UAAW,GAAM,CAAC,GAAK,KAC1H,GAAmB,EAAgB,OAAO,IAAI,WAAa,CAAC,SAAW,IAMzE,EAAkB,OAGf,EAGT,SAAgB,EAAW,EAAyB,CAClD,OAAO,GAAoB,CACvB,EAAgB,OAAO,EAAI,CAC3B,EAAoB,EAAI,CAG9B,SAAgB,EAAO,EAAa,EAAe,EAAgB,EAAS,GAAI,CAC9E,OAAO,EAAI,MAAM,EAAG,EAAM,CAAG,EAAS,EAAI,MAAM,EAAQ,EAAO"}

package/dist/common/bin/lib0/string.d.cts

@@ -1,3 +1,4 @@
+//#region src/common/bin/lib0/string.d.ts
 /**
  * Original at https://github.com/dmonad/lib0
  *
@@ -15,5 +16,6 @@ declare function encodeUtf8(str: string): Uint8Array;
 declare function getUtf8TextDecoder(): TextDecoder | undefined;
 declare function decodeUtf8(buf: Uint8Array): string;
 declare function splice(str: string, index: number, remove: number, insert?: string): string;
-
+//#endregion
 export { _encodeUtf8Polyfill, decodeUtf8, encodeUtf8, fromCamelCase, getUtf8TextDecoder, getUtf8TextEncoder, splice, trimLeft, utf8ByteLength };
+//# sourceMappingURL=string.d.cts.map

package/dist/common/bin/lib0/string.d.mts

@@ -0,0 +1,21 @@
+//#region src/common/bin/lib0/string.d.ts
+/**
+ * Original at https://github.com/dmonad/lib0
+ *
+ * Utility module to work with strings.
+ */
+declare function trimLeft(s: string): string;
+declare function fromCamelCase(s: string, separator: string): string;
+/**
+ * Compute the utf8ByteLength
+ */
+declare function utf8ByteLength(str: string): number;
+declare function _encodeUtf8Polyfill(str: string): Uint8Array;
+declare function getUtf8TextEncoder(): TextEncoder | null;
+declare function encodeUtf8(str: string): Uint8Array;
+declare function getUtf8TextDecoder(): TextDecoder | undefined;
+declare function decodeUtf8(buf: Uint8Array): string;
+declare function splice(str: string, index: number, remove: number, insert?: string): string;
+//#endregion
+export { _encodeUtf8Polyfill, decodeUtf8, encodeUtf8, fromCamelCase, getUtf8TextDecoder, getUtf8TextEncoder, splice, trimLeft, utf8ByteLength };
+//# sourceMappingURL=string.d.mts.map

package/dist/common/bin/lib0/string.mjs

@@ -0,0 +1,2 @@
+function e(e){return e.toLowerCase()}const t=/^\s*/g;function n(e){return e.replace(t,``)}const r=/([A-Z])/g;function i(t,i){return n(t.replace(r,t=>`${i}${e(t)}`))}function a(e){return unescape(encodeURIComponent(e)).length}function o(e){let t=unescape(encodeURIComponent(e)),n=t.length,r=new Uint8Array(n);for(let e=0;e<n;e++)r[e]=t.codePointAt(e);return r}let s;function c(){return s===void 0&&(s=typeof TextEncoder<`u`?new TextEncoder:null),s}function l(e){return c()?s.encode(e):o(e)}function u(e){let t=e.length,n=``,r=0;for(;t>0;){let i=t<1e4?t:1e4,a=e.subarray(r,r+i);r+=i,n+=String.fromCodePoint(...a),t-=i}return decodeURIComponent(escape(n))}let d;function f(){return d===void 0&&(d=(typeof TextDecoder>`u`?null:new TextDecoder(`utf-8`,{fatal:!0,ignoreBOM:!0}))??null,d&&d.decode(new Uint8Array).length===1&&(d=null)),d}function p(e){return f()?d.decode(e):u(e)}function m(e,t,n,r=``){return e.slice(0,t)+r+e.slice(t+n)}export{o as _encodeUtf8Polyfill,p as decodeUtf8,l as encodeUtf8,i as fromCamelCase,f as getUtf8TextDecoder,c as getUtf8TextEncoder,m as splice,n as trimLeft,a as utf8ByteLength};
+//# sourceMappingURL=string.mjs.map

package/dist/common/bin/lib0/string.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.mjs","names":[],"sources":["../../../../src/common/bin/lib0/string.ts"],"sourcesContent":["/**\n * Original at https://github.com/dmonad/lib0\n *\n * Utility module to work with strings.\n */\n\n// export const fromCharCode = String.fromCharCode\n// export const fromCodePoint = String.fromCodePoint\n\nfunction toLowerCase(s: string): string {\n  return s.toLowerCase()\n}\n\nconst trimLeftRegex = /^\\s*/g\n\nexport function trimLeft(s: string): string {\n  return s.replace(trimLeftRegex, '')\n}\n\nconst fromCamelCaseRegex = /([A-Z])/g\n\nexport function fromCamelCase(s: string, separator: string): string {\n  return trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`))\n}\n\n/**\n * Compute the utf8ByteLength\n */\nexport function utf8ByteLength(str: string): number {\n  return unescape(encodeURIComponent(str)).length\n}\n\nexport function _encodeUtf8Polyfill(str: string): Uint8Array {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  const buf = new Uint8Array(len)\n  for (let i = 0; i < len; i++)\n    buf[i] = (encodedString.codePointAt(i) as number)\n\n  return buf\n}\n\nlet utf8TextEncoder: TextEncoder | undefined | null\n\nexport function getUtf8TextEncoder(): TextEncoder | null {\n  if (utf8TextEncoder === undefined)\n    utf8TextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null)\n  return utf8TextEncoder\n}\n\nexport function encodeUtf8(str: string): Uint8Array {\n  return getUtf8TextEncoder()\n    ? utf8TextEncoder!.encode(str)\n    : _encodeUtf8Polyfill(str)\n}\n\nfunction _decodeUtf8Polyfill(buf: Uint8Array): string {\n  let remainingLen = buf.length\n  let encodedString = ''\n  let bufPos = 0\n  while (remainingLen > 0) {\n    const nextLen = remainingLen < 10000 ? remainingLen : 10000\n    const bytes = buf.subarray(bufPos, bufPos + nextLen)\n    bufPos += nextLen\n    // Starting with ES5.1 we can supply a generic array-like object as arguments\n    encodedString += String.fromCodePoint(...bytes as any)\n    remainingLen -= nextLen\n  }\n  return decodeURIComponent(escape(encodedString))\n}\n\nlet utf8TextDecoder: any\n\nexport function getUtf8TextDecoder(): TextDecoder | undefined {\n  if (utf8TextDecoder === undefined) {\n    utf8TextDecoder = (typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })) ?? null\n    if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {\n      // Safari doesn't handle BOM correctly.\n      // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.\n      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and\n      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call\n      // Another issue is that from then on no BOM chars are recognized anymore\n      utf8TextDecoder = null\n    }\n  }\n  return utf8TextDecoder\n}\n\nexport function decodeUtf8(buf: Uint8Array): string {\n  return getUtf8TextDecoder()\n    ? utf8TextDecoder.decode(buf)\n    : _decodeUtf8Polyfill(buf)\n}\n\nexport function splice(str: string, index: number, remove: number, insert = '') {\n  return str.slice(0, index) + insert + str.slice(index + remove)\n}\n"],"mappings":"AASA,SAAS,EAAY,EAAmB,CACtC,OAAO,EAAE,aAAa,CAGxB,MAAM,EAAgB,QAEtB,SAAgB,EAAS,EAAmB,CAC1C,OAAO,EAAE,QAAQ,EAAe,GAAG,CAGrC,MAAM,EAAqB,WAE3B,SAAgB,EAAc,EAAW,EAA2B,CAClE,OAAO,EAAS,EAAE,QAAQ,EAAoB,GAAS,GAAG,IAAY,EAAY,EAAM,GAAG,CAAC,CAM9F,SAAgB,EAAe,EAAqB,CAClD,OAAO,SAAS,mBAAmB,EAAI,CAAC,CAAC,OAG3C,SAAgB,EAAoB,EAAyB,CAC3D,IAAM,EAAgB,SAAS,mBAAmB,EAAI,CAAC,CACjD,EAAM,EAAc,OACpB,EAAM,IAAI,WAAW,EAAI,CAC/B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,IACvB,EAAI,GAAM,EAAc,YAAY,EAAE,CAExC,OAAO,EAGT,IAAI,EAEJ,SAAgB,GAAyC,CAGvD,OAFI,IAAoB,IAAA,KACtB,EAAmB,OAAO,YAAgB,IAAc,IAAI,YAAgB,MACvE,EAGT,SAAgB,EAAW,EAAyB,CAClD,OAAO,GAAoB,CACvB,EAAiB,OAAO,EAAI,CAC5B,EAAoB,EAAI,CAG9B,SAAS,EAAoB,EAAyB,CACpD,IAAI,EAAe,EAAI,OACnB,EAAgB,GAChB,EAAS,EACb,KAAO,EAAe,GAAG,CACvB,IAAM,EAAU,EAAe,IAAQ,EAAe,IAChD,EAAQ,EAAI,SAAS,EAAQ,EAAS,EAAQ,CACpD,GAAU,EAEV,GAAiB,OAAO,cAAc,GAAG,EAAa,CACtD,GAAgB,EAElB,OAAO,mBAAmB,OAAO,EAAc,CAAC,CAGlD,IAAI,EAEJ,SAAgB,GAA8C,CAY5D,OAXI,IAAoB,IAAA,KACtB,GAAmB,OAAO,YAAgB,IAAc,KAAO,IAAI,YAAY,QAAS,CAAE,MAAO,GAAM,UAAW,GAAM,CAAC,GAAK,KAC1H,GAAmB,EAAgB,OAAO,IAAI,WAAa,CAAC,SAAW,IAMzE,EAAkB,OAGf,EAGT,SAAgB,EAAW,EAAyB,CAClD,OAAO,GAAoB,CACvB,EAAgB,OAAO,EAAI,CAC3B,EAAoB,EAAI,CAG9B,SAAgB,EAAO,EAAa,EAAe,EAAgB,EAAS,GAAI,CAC9E,OAAO,EAAI,MAAM,EAAG,EAAM,CAAG,EAAS,EAAI,MAAM,EAAQ,EAAO"}

package/dist/common/crypto/aes-sealed.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkL5IXZXHRcjs = require('../../chunk-L5IXZXHR.cjs');require('../../chunk-TNMEWZPW.cjs');require('../../chunk-5RHVNJKM.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.decryptAesGcm = _chunkL5IXZXHRcjs.b; exports.encryptAesGcm = _chunkL5IXZXHRcjs.a;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../bin-Ce3i6ABn.cjs`);async function t(t,n,r=new Uint8Array){let i=crypto.getRandomValues(new Uint8Array(12)),a=await crypto.subtle.encrypt({name:`AES-GCM`,iv:i,tagLength:128,additionalData:e.o(r)},n,e.o(t)),o=new Uint8Array(a),s=new Uint8Array(i.length+o.length);return s.set(i),s.set(o,i.length),s}async function n(t,n,r=new Uint8Array){let i=e.o(t.slice(0,12)),a=e.o(t.slice(12)),o=await crypto.subtle.decrypt({name:`AES-GCM`,iv:i,tagLength:128,additionalData:e.o(r)},n,a);return new Uint8Array(o)}exports.decryptAesGcm=n,exports.encryptAesGcm=t;
 //# sourceMappingURL=aes-sealed.cjs.map

package/dist/common/crypto/aes-sealed.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/crypto/aes-sealed.cjs"],"names":[],"mappings":"AAAA,qIAAyC,oCAAiC,oCAAiC,oCAAiC,yFAA8C","file":"/Users/dirk/work/github-zeed/dist/common/crypto/aes-sealed.cjs"}
+{"version":3,"file":"aes-sealed.cjs","names":["ensureUint8Array"],"sources":["../../../src/common/crypto/aes-sealed.ts"],"sourcesContent":["import { ensureUint8Array } from '../data/bin'\n\nconst AES_GCM_TAG_LENGTH_BITS = 128\n\nexport async function encryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating: Uint8Array = new Uint8Array()): Promise<Uint8Array> {\n  const iv = crypto.getRandomValues(new Uint8Array(12)) // AES-GCM requires a 12-byte IV\n  const encrypted = await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv,\n      tagLength: AES_GCM_TAG_LENGTH_BITS,\n      additionalData: ensureUint8Array(authenticating),\n    },\n    key,\n    ensureUint8Array(data),\n  )\n\n  const encryptedArray = new Uint8Array(encrypted)\n  const combined = new Uint8Array(iv.length + encryptedArray.length)\n  combined.set(iv)\n  combined.set(encryptedArray, iv.length)\n  return combined\n}\n\nexport async function decryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating: Uint8Array = new Uint8Array()): Promise<Uint8Array> {\n  const iv = ensureUint8Array(data.slice(0, 12)) // nonce is the first 12 bytes\n  const encrypted = ensureUint8Array(data.slice(12)) // ciphertext and tag of 128 bits\n  const decrypted = await crypto.subtle.decrypt({\n    name: 'AES-GCM',\n    iv,\n    tagLength: AES_GCM_TAG_LENGTH_BITS,\n    additionalData: ensureUint8Array(authenticating),\n  }, key, encrypted)\n  return new Uint8Array(decrypted)\n}\n"],"mappings":"6GAIA,eAAsB,EAAc,EAAkB,EAAgB,EAA6B,IAAI,WAAmC,CACxI,IAAM,EAAK,OAAO,gBAAgB,IAAI,WAAW,GAAG,CAAC,CAC/C,EAAY,MAAM,OAAO,OAAO,QACpC,CACE,KAAM,UACN,KACA,UAAW,IACX,eAAgBA,EAAAA,EAAiB,EAAe,CACjD,CACD,EACAA,EAAAA,EAAiB,EAAK,CACvB,CAEK,EAAiB,IAAI,WAAW,EAAU,CAC1C,EAAW,IAAI,WAAW,EAAG,OAAS,EAAe,OAAO,CAGlE,OAFA,EAAS,IAAI,EAAG,CAChB,EAAS,IAAI,EAAgB,EAAG,OAAO,CAChC,EAGT,eAAsB,EAAc,EAAkB,EAAgB,EAA6B,IAAI,WAAmC,CACxI,IAAM,EAAKA,EAAAA,EAAiB,EAAK,MAAM,EAAG,GAAG,CAAC,CACxC,EAAYA,EAAAA,EAAiB,EAAK,MAAM,GAAG,CAAC,CAC5C,EAAY,MAAM,OAAO,OAAO,QAAQ,CAC5C,KAAM,UACN,KACA,UAAW,IACX,eAAgBA,EAAAA,EAAiB,EAAe,CACjD,CAAE,EAAK,EAAU,CAClB,OAAO,IAAI,WAAW,EAAU"}

package/dist/common/crypto/aes-sealed.d.cts

@@ -1,4 +1,2 @@
-declare function encryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating?: Uint8Array): Promise<Uint8Array>;
-declare function decryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating?: Uint8Array): Promise<Uint8Array>;
-
-export { decryptAesGcm, encryptAesGcm };
+import { n as encryptAesGcm, t as decryptAesGcm } from "../../aes-sealed-Q4saTGg2.cjs";
+export { decryptAesGcm, encryptAesGcm };

package/dist/common/crypto/aes-sealed.d.mts

@@ -0,0 +1,2 @@
+import { n as encryptAesGcm, t as decryptAesGcm } from "../../aes-sealed-CEgjlCzA.mjs";
+export { decryptAesGcm, encryptAesGcm };

package/dist/common/crypto/aes-sealed.mjs

@@ -0,0 +1,2 @@
+import{o as e}from"../../bin-SPdenYkw.mjs";async function t(t,n,r=new Uint8Array){let i=crypto.getRandomValues(new Uint8Array(12)),a=await crypto.subtle.encrypt({name:`AES-GCM`,iv:i,tagLength:128,additionalData:e(r)},n,e(t)),o=new Uint8Array(a),s=new Uint8Array(i.length+o.length);return s.set(i),s.set(o,i.length),s}async function n(t,n,r=new Uint8Array){let i=e(t.slice(0,12)),a=e(t.slice(12)),o=await crypto.subtle.decrypt({name:`AES-GCM`,iv:i,tagLength:128,additionalData:e(r)},n,a);return new Uint8Array(o)}export{n as decryptAesGcm,t as encryptAesGcm};
+//# sourceMappingURL=aes-sealed.mjs.map

package/dist/common/crypto/aes-sealed.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes-sealed.mjs","names":[],"sources":["../../../src/common/crypto/aes-sealed.ts"],"sourcesContent":["import { ensureUint8Array } from '../data/bin'\n\nconst AES_GCM_TAG_LENGTH_BITS = 128\n\nexport async function encryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating: Uint8Array = new Uint8Array()): Promise<Uint8Array> {\n  const iv = crypto.getRandomValues(new Uint8Array(12)) // AES-GCM requires a 12-byte IV\n  const encrypted = await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv,\n      tagLength: AES_GCM_TAG_LENGTH_BITS,\n      additionalData: ensureUint8Array(authenticating),\n    },\n    key,\n    ensureUint8Array(data),\n  )\n\n  const encryptedArray = new Uint8Array(encrypted)\n  const combined = new Uint8Array(iv.length + encryptedArray.length)\n  combined.set(iv)\n  combined.set(encryptedArray, iv.length)\n  return combined\n}\n\nexport async function decryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating: Uint8Array = new Uint8Array()): Promise<Uint8Array> {\n  const iv = ensureUint8Array(data.slice(0, 12)) // nonce is the first 12 bytes\n  const encrypted = ensureUint8Array(data.slice(12)) // ciphertext and tag of 128 bits\n  const decrypted = await crypto.subtle.decrypt({\n    name: 'AES-GCM',\n    iv,\n    tagLength: AES_GCM_TAG_LENGTH_BITS,\n    additionalData: ensureUint8Array(authenticating),\n  }, key, encrypted)\n  return new Uint8Array(decrypted)\n}\n"],"mappings":"2CAIA,eAAsB,EAAc,EAAkB,EAAgB,EAA6B,IAAI,WAAmC,CACxI,IAAM,EAAK,OAAO,gBAAgB,IAAI,WAAW,GAAG,CAAC,CAC/C,EAAY,MAAM,OAAO,OAAO,QACpC,CACE,KAAM,UACN,KACA,UAAW,IACX,eAAgB,EAAiB,EAAe,CACjD,CACD,EACA,EAAiB,EAAK,CACvB,CAEK,EAAiB,IAAI,WAAW,EAAU,CAC1C,EAAW,IAAI,WAAW,EAAG,OAAS,EAAe,OAAO,CAGlE,OAFA,EAAS,IAAI,EAAG,CAChB,EAAS,IAAI,EAAgB,EAAG,OAAO,CAChC,EAGT,eAAsB,EAAc,EAAkB,EAAgB,EAA6B,IAAI,WAAmC,CACxI,IAAM,EAAK,EAAiB,EAAK,MAAM,EAAG,GAAG,CAAC,CACxC,EAAY,EAAiB,EAAK,MAAM,GAAG,CAAC,CAC5C,EAAY,MAAM,OAAO,OAAO,QAAQ,CAC5C,KAAM,UACN,KACA,UAAW,IACX,eAAgB,EAAiB,EAAe,CACjD,CAAE,EAAK,EAAU,CAClB,OAAO,IAAI,WAAW,EAAU"}

package/dist/common/crypto/crypto.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkLUPESR7Scjs = require('../../chunk-LUPESR7S.cjs');require('../../chunk-TNMEWZPW.cjs');require('../../chunk-5RHVNJKM.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.CRYPTO_DEFAULT_ALG = _chunkLUPESR7Scjs.c; exports.CRYPTO_DEFAULT_DERIVE_ALG = _chunkLUPESR7Scjs.d; exports.CRYPTO_DEFAULT_DERIVE_ITERATIONS = _chunkLUPESR7Scjs.e; exports.CRYPTO_DEFAULT_HASH_ALG = _chunkLUPESR7Scjs.b; exports.CRYPTO_DEFAULT_IV_LENGTH = _chunkLUPESR7Scjs.f; exports.decrypt = _chunkLUPESR7Scjs.k; exports.deriveKeyPbkdf2 = _chunkLUPESR7Scjs.h; exports.deriveKeyPbkdf2CBC = _chunkLUPESR7Scjs.i; exports.digest = _chunkLUPESR7Scjs.g; exports.encrypt = _chunkLUPESR7Scjs.j; exports.randomUint8Array = _chunkLUPESR7Scjs.a;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../bin-Ce3i6ABn.cjs`);function t(e=16){let t=new Uint8Array(e);if(typeof crypto<`u`&&crypto.getRandomValues)crypto.getRandomValues(t);else for(let n=0;n<e;n++)t[n]=Math.floor(Math.random()*256);return t}const n=`SHA-256`,r=`AES-GCM`,i=`PBKDF2`;async function a(t,r=n){let i=e.o(e.v(t));return e.v(await crypto.subtle.digest(r,i))}async function o(t,a={}){let o=e.o(e.v(t)),s=await crypto.subtle.importKey(`raw`,o,i,!1,[`deriveKey`]);return await crypto.subtle.deriveKey({name:i,salt:a.salt?e.o(e.v(a.salt)):new Uint8Array,iterations:a.iterations??1e5,hash:n},s,{name:r,length:256},!0,[`encrypt`,`decrypt`])}async function s(t,r={}){let a=e.o(e.v(t)),o=await crypto.subtle.importKey(`raw`,a,i,!1,[`deriveKey`]);return await crypto.subtle.deriveKey({name:i,salt:r.salt?e.o(e.v(r.salt)):new Uint8Array,iterations:r.iterations??1e5,hash:n},o,{name:`AES-CBC`,length:256},!0,[`encrypt`,`decrypt`])}function c(){return new Uint8Array([1,1])}async function l(n,i){let a=c(),o=t(12),s=await crypto.subtle.encrypt({name:r,iv:e.o(o)},i,e.o(n)),l=new Uint8Array(s),u=a.length+o.length+l.length,d=new Uint8Array(u),f=0;return d.set(a,f),f+=a.length,d.set(o,f),f+=o.length,d.set(l,f),d}async function u(t,n){let i=e.o(t.subarray(0,2));if(!e.s(i,c()))return Promise.reject(Error(`Unknown magic ${i}`));let a=e.o(t.subarray(2,14)),o=e.o(t.subarray(14,t.length)),s=await crypto.subtle.decrypt({name:r,iv:a},n,o);return new Uint8Array(s)}exports.CRYPTO_DEFAULT_ALG=r,exports.CRYPTO_DEFAULT_DERIVE_ALG=i,exports.CRYPTO_DEFAULT_DERIVE_ITERATIONS=1e5,exports.CRYPTO_DEFAULT_HASH_ALG=n,exports.CRYPTO_DEFAULT_IV_LENGTH=12,exports.decrypt=u,exports.deriveKeyPbkdf2=o,exports.deriveKeyPbkdf2CBC=s,exports.digest=a,exports.encrypt=l,exports.randomUint8Array=t;
 //# sourceMappingURL=crypto.cjs.map

package/dist/common/crypto/crypto.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/crypto/crypto.cjs"],"names":[],"mappings":"AAAA,qIAA2D,oCAAiC,oCAAiC,oCAAiC,8hBAAyQ","file":"/Users/dirk/work/github-zeed/dist/common/crypto/crypto.cjs"}
+{"version":3,"file":"crypto.cjs","names":["ensureUint8Array","toUint8Array","equalBinary"],"sources":["../../../src/common/crypto/crypto.ts"],"sourcesContent":["import type { BinInput } from '../data/bin-types'\nimport { ensureUint8Array, equalBinary, toUint8Array } from '../data/bin'\n\n/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */\nexport function randomUint8Array(length = 16): Uint8Array {\n  const randomBytes = new Uint8Array(length)\n  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {\n    crypto.getRandomValues(randomBytes)\n  }\n  else {\n    // hack: not state of the art secure\n    // throw \"crypto.getRandomValues is required\"\n    for (let i = 0; i < length; i++) {\n      // Math.random: \"...range 0 to less than 1 (inclusive of 0, but not 1)\"\n      // 0.9... * 0xff < 255 therefore * 0x100\n      randomBytes[i] = Math.floor(Math.random() * 0x100) // 0...255\n    }\n  }\n  return randomBytes\n}\n\nexport const CRYPTO_DEFAULT_HASH_ALG = 'SHA-256'\nexport const CRYPTO_DEFAULT_ALG = 'AES-GCM'\nexport const CRYPTO_DEFAULT_DERIVE_ALG = 'PBKDF2'\nexport const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 100000\nexport const CRYPTO_DEFAULT_IV_LENGTH = 12\n\nexport async function digest(\n  message: BinInput,\n  algorithm: AlgorithmIdentifier = CRYPTO_DEFAULT_HASH_ALG,\n): Promise<Uint8Array> {\n  const m = ensureUint8Array(toUint8Array(message))\n  return toUint8Array(\n    await crypto.subtle.digest(algorithm, m),\n  )\n}\n\nexport async function deriveKeyPbkdf2(\n  secret: BinInput,\n  opt: {\n    iterations?: number\n    salt?: BinInput\n  } = {},\n): Promise<CryptoKey> {\n  const secretBuffer = ensureUint8Array(toUint8Array(secret))\n  const keyMaterial = await crypto.subtle.importKey(\n    'raw',\n    secretBuffer,\n    CRYPTO_DEFAULT_DERIVE_ALG,\n    false,\n    ['deriveKey'],\n  )\n  return await crypto.subtle.deriveKey(\n    {\n      name: CRYPTO_DEFAULT_DERIVE_ALG,\n      salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),\n      iterations: opt.iterations ?? CRYPTO_DEFAULT_DERIVE_ITERATIONS,\n      hash: CRYPTO_DEFAULT_HASH_ALG,\n    },\n    keyMaterial,\n    {\n      name: CRYPTO_DEFAULT_ALG,\n      length: 256,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  )\n}\n\nexport async function deriveKeyPbkdf2CBC(\n  secret: BinInput,\n  opt: {\n    iterations?: number\n    salt?: BinInput\n  } = {},\n): Promise<CryptoKey> {\n  const secretBuffer = ensureUint8Array(toUint8Array(secret))\n  const keyMaterial = await crypto.subtle.importKey(\n    'raw',\n    secretBuffer,\n    CRYPTO_DEFAULT_DERIVE_ALG,\n    false,\n    ['deriveKey'],\n  )\n  return await crypto.subtle.deriveKey(\n    {\n      name: CRYPTO_DEFAULT_DERIVE_ALG,\n      salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),\n      iterations: opt.iterations ?? CRYPTO_DEFAULT_DERIVE_ITERATIONS,\n      hash: CRYPTO_DEFAULT_HASH_ALG,\n    },\n    keyMaterial,\n    {\n      name: 'AES-CBC',\n      length: 256,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  )\n}\n\nfunction getMagicId() {\n  return new Uint8Array([1, 1])\n}\n\nexport async function encrypt(\n  data: Uint8Array,\n  key: CryptoKey,\n): Promise<Uint8Array> {\n  const MAGIC_ID = getMagicId()\n  const iv = randomUint8Array(CRYPTO_DEFAULT_IV_LENGTH)\n  const cipher = await crypto.subtle.encrypt(\n    { name: CRYPTO_DEFAULT_ALG, iv: ensureUint8Array(iv) },\n    key,\n    ensureUint8Array(data),\n  )\n  const binCypher = new Uint8Array(cipher)\n  const bufferLength = MAGIC_ID.length + iv.length + binCypher.length\n  const buffer = new Uint8Array(bufferLength)\n  let pos = 0\n  buffer.set(MAGIC_ID, pos)\n  pos += MAGIC_ID.length\n  buffer.set(iv, pos)\n  pos += iv.length\n  buffer.set(binCypher, pos)\n  return buffer\n}\n\nexport async function decrypt(\n  data: Uint8Array,\n  key: CryptoKey,\n): Promise<Uint8Array> {\n  const magic = ensureUint8Array(data.subarray(0, 2))\n  if (!equalBinary(magic, getMagicId()))\n    return Promise.reject(new Error(`Unknown magic ${magic}`))\n\n  const iv = ensureUint8Array(data.subarray(2, 2 + CRYPTO_DEFAULT_IV_LENGTH))\n  const cipher = ensureUint8Array(data.subarray(2 + CRYPTO_DEFAULT_IV_LENGTH, data.length))\n  const plain = await crypto.subtle.decrypt(\n    { name: CRYPTO_DEFAULT_ALG, iv },\n    key,\n    cipher,\n  )\n  return new Uint8Array(plain)\n}\n"],"mappings":"6GAIA,SAAgB,EAAiB,EAAS,GAAgB,CACxD,IAAM,EAAc,IAAI,WAAW,EAAO,CAC1C,GAAI,OAAO,OAAW,KAAe,OAAO,gBAC1C,OAAO,gBAAgB,EAAY,MAKnC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAG1B,EAAY,GAAK,KAAK,MAAM,KAAK,QAAQ,CAAG,IAAM,CAGtD,OAAO,EAGT,MAAa,EAA0B,UAC1B,EAAqB,UACrB,EAA4B,SAIzC,eAAsB,EACpB,EACA,EAAiC,EACZ,CACrB,IAAM,EAAIA,EAAAA,EAAiBC,EAAAA,EAAa,EAAQ,CAAC,CACjD,OAAOA,EAAAA,EACL,MAAM,OAAO,OAAO,OAAO,EAAW,EAAE,CACzC,CAGH,eAAsB,EACpB,EACA,EAGI,EAAE,CACc,CACpB,IAAM,EAAeD,EAAAA,EAAiBC,EAAAA,EAAa,EAAO,CAAC,CACrD,EAAc,MAAM,OAAO,OAAO,UACtC,MACA,EACA,EACA,GACA,CAAC,YAAY,CACd,CACD,OAAO,MAAM,OAAO,OAAO,UACzB,CACE,KAAM,EACN,KAAM,EAAI,KAAOD,EAAAA,EAAiBC,EAAAA,EAAa,EAAI,KAAK,CAAC,CAAG,IAAI,WAChE,WAAY,EAAI,YAAA,IAChB,KAAM,EACP,CACD,EACA,CACE,KAAM,EACN,OAAQ,IACT,CACD,GACA,CAAC,UAAW,UAAU,CACvB,CAGH,eAAsB,EACpB,EACA,EAGI,EAAE,CACc,CACpB,IAAM,EAAeD,EAAAA,EAAiBC,EAAAA,EAAa,EAAO,CAAC,CACrD,EAAc,MAAM,OAAO,OAAO,UACtC,MACA,EACA,EACA,GACA,CAAC,YAAY,CACd,CACD,OAAO,MAAM,OAAO,OAAO,UACzB,CACE,KAAM,EACN,KAAM,EAAI,KAAOD,EAAAA,EAAiBC,EAAAA,EAAa,EAAI,KAAK,CAAC,CAAG,IAAI,WAChE,WAAY,EAAI,YAAA,IAChB,KAAM,EACP,CACD,EACA,CACE,KAAM,UACN,OAAQ,IACT,CACD,GACA,CAAC,UAAW,UAAU,CACvB,CAGH,SAAS,GAAa,CACpB,OAAO,IAAI,WAAW,CAAC,EAAG,EAAE,CAAC,CAG/B,eAAsB,EACpB,EACA,EACqB,CACrB,IAAM,EAAW,GAAY,CACvB,EAAK,EAAA,GAA0C,CAC/C,EAAS,MAAM,OAAO,OAAO,QACjC,CAAE,KAAM,EAAoB,GAAID,EAAAA,EAAiB,EAAG,CAAE,CACtD,EACAA,EAAAA,EAAiB,EAAK,CACvB,CACK,EAAY,IAAI,WAAW,EAAO,CAClC,EAAe,EAAS,OAAS,EAAG,OAAS,EAAU,OACvD,EAAS,IAAI,WAAW,EAAa,CACvC,EAAM,EAMV,OALA,EAAO,IAAI,EAAU,EAAI,CACzB,GAAO,EAAS,OAChB,EAAO,IAAI,EAAI,EAAI,CACnB,GAAO,EAAG,OACV,EAAO,IAAI,EAAW,EAAI,CACnB,EAGT,eAAsB,EACpB,EACA,EACqB,CACrB,IAAM,EAAQA,EAAAA,EAAiB,EAAK,SAAS,EAAG,EAAE,CAAC,CACnD,GAAI,CAACE,EAAAA,EAAY,EAAO,GAAY,CAAC,CACnC,OAAO,QAAQ,OAAW,MAAM,iBAAiB,IAAQ,CAAC,CAE5D,IAAM,EAAKF,EAAAA,EAAiB,EAAK,SAAS,EAAG,GAA6B,CAAC,CACrE,EAASA,EAAAA,EAAiB,EAAK,SAAS,GAA8B,EAAK,OAAO,CAAC,CACnF,EAAQ,MAAM,OAAO,OAAO,QAChC,CAAE,KAAM,EAAoB,KAAI,CAChC,EACA,EACD,CACD,OAAO,IAAI,WAAW,EAAM"}

package/dist/common/crypto/crypto.d.cts

@@ -1,22 +1,2 @@
-import { BinInput } from '../data/bin-types.cjs';
-
-/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */
-declare function randomUint8Array(length?: number): Uint8Array;
-declare const CRYPTO_DEFAULT_HASH_ALG = "SHA-256";
-declare const CRYPTO_DEFAULT_ALG = "AES-GCM";
-declare const CRYPTO_DEFAULT_DERIVE_ALG = "PBKDF2";
-declare const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 100000;
-declare const CRYPTO_DEFAULT_IV_LENGTH = 12;
-declare function digest(message: BinInput, algorithm?: AlgorithmIdentifier): Promise<Uint8Array>;
-declare function deriveKeyPbkdf2(secret: BinInput, opt?: {
-    iterations?: number;
-    salt?: BinInput;
-}): Promise<CryptoKey>;
-declare function deriveKeyPbkdf2CBC(secret: BinInput, opt?: {
-    iterations?: number;
-    salt?: BinInput;
-}): Promise<CryptoKey>;
-declare function encrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
-declare function decrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
-
-export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array };
+import { a as CRYPTO_DEFAULT_IV_LENGTH, c as deriveKeyPbkdf2CBC, d as randomUint8Array, i as CRYPTO_DEFAULT_HASH_ALG, l as digest, n as CRYPTO_DEFAULT_DERIVE_ALG, o as decrypt, r as CRYPTO_DEFAULT_DERIVE_ITERATIONS, s as deriveKeyPbkdf2, t as CRYPTO_DEFAULT_ALG, u as encrypt } from "../../crypto-C8VaLy62.cjs";
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array };

package/dist/common/crypto/crypto.d.mts

@@ -0,0 +1,2 @@
+import { a as CRYPTO_DEFAULT_IV_LENGTH, c as deriveKeyPbkdf2CBC, d as randomUint8Array, i as CRYPTO_DEFAULT_HASH_ALG, l as digest, n as CRYPTO_DEFAULT_DERIVE_ALG, o as decrypt, r as CRYPTO_DEFAULT_DERIVE_ITERATIONS, s as deriveKeyPbkdf2, t as CRYPTO_DEFAULT_ALG, u as encrypt } from "../../crypto-D4uSzFEL.mjs";
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array };

package/dist/common/crypto/crypto.mjs

@@ -0,0 +1,2 @@
+import{o as e,s as t,v as n}from"../../bin-SPdenYkw.mjs";function r(e=16){let t=new Uint8Array(e);if(typeof crypto<`u`&&crypto.getRandomValues)crypto.getRandomValues(t);else for(let n=0;n<e;n++)t[n]=Math.floor(Math.random()*256);return t}const i=`SHA-256`,a=`AES-GCM`,o=`PBKDF2`,s=1e5,c=12;async function l(t,r=i){let a=e(n(t));return n(await crypto.subtle.digest(r,a))}async function u(t,r={}){let s=e(n(t)),c=await crypto.subtle.importKey(`raw`,s,o,!1,[`deriveKey`]);return await crypto.subtle.deriveKey({name:o,salt:r.salt?e(n(r.salt)):new Uint8Array,iterations:r.iterations??1e5,hash:i},c,{name:a,length:256},!0,[`encrypt`,`decrypt`])}async function d(t,r={}){let a=e(n(t)),s=await crypto.subtle.importKey(`raw`,a,o,!1,[`deriveKey`]);return await crypto.subtle.deriveKey({name:o,salt:r.salt?e(n(r.salt)):new Uint8Array,iterations:r.iterations??1e5,hash:i},s,{name:`AES-CBC`,length:256},!0,[`encrypt`,`decrypt`])}function f(){return new Uint8Array([1,1])}async function p(t,n){let i=f(),o=r(12),s=await crypto.subtle.encrypt({name:a,iv:e(o)},n,e(t)),c=new Uint8Array(s),l=i.length+o.length+c.length,u=new Uint8Array(l),d=0;return u.set(i,d),d+=i.length,u.set(o,d),d+=o.length,u.set(c,d),u}async function m(n,r){let i=e(n.subarray(0,2));if(!t(i,f()))return Promise.reject(Error(`Unknown magic ${i}`));let o=e(n.subarray(2,14)),s=e(n.subarray(14,n.length)),c=await crypto.subtle.decrypt({name:a,iv:o},r,s);return new Uint8Array(c)}export{a as CRYPTO_DEFAULT_ALG,o as CRYPTO_DEFAULT_DERIVE_ALG,s as CRYPTO_DEFAULT_DERIVE_ITERATIONS,i as CRYPTO_DEFAULT_HASH_ALG,c as CRYPTO_DEFAULT_IV_LENGTH,m as decrypt,u as deriveKeyPbkdf2,d as deriveKeyPbkdf2CBC,l as digest,p as encrypt,r as randomUint8Array};
+//# sourceMappingURL=crypto.mjs.map

package/dist/common/crypto/crypto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.mjs","names":[],"sources":["../../../src/common/crypto/crypto.ts"],"sourcesContent":["import type { BinInput } from '../data/bin-types'\nimport { ensureUint8Array, equalBinary, toUint8Array } from '../data/bin'\n\n/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */\nexport function randomUint8Array(length = 16): Uint8Array {\n  const randomBytes = new Uint8Array(length)\n  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {\n    crypto.getRandomValues(randomBytes)\n  }\n  else {\n    // hack: not state of the art secure\n    // throw \"crypto.getRandomValues is required\"\n    for (let i = 0; i < length; i++) {\n      // Math.random: \"...range 0 to less than 1 (inclusive of 0, but not 1)\"\n      // 0.9... * 0xff < 255 therefore * 0x100\n      randomBytes[i] = Math.floor(Math.random() * 0x100) // 0...255\n    }\n  }\n  return randomBytes\n}\n\nexport const CRYPTO_DEFAULT_HASH_ALG = 'SHA-256'\nexport const CRYPTO_DEFAULT_ALG = 'AES-GCM'\nexport const CRYPTO_DEFAULT_DERIVE_ALG = 'PBKDF2'\nexport const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 100000\nexport const CRYPTO_DEFAULT_IV_LENGTH = 12\n\nexport async function digest(\n  message: BinInput,\n  algorithm: AlgorithmIdentifier = CRYPTO_DEFAULT_HASH_ALG,\n): Promise<Uint8Array> {\n  const m = ensureUint8Array(toUint8Array(message))\n  return toUint8Array(\n    await crypto.subtle.digest(algorithm, m),\n  )\n}\n\nexport async function deriveKeyPbkdf2(\n  secret: BinInput,\n  opt: {\n    iterations?: number\n    salt?: BinInput\n  } = {},\n): Promise<CryptoKey> {\n  const secretBuffer = ensureUint8Array(toUint8Array(secret))\n  const keyMaterial = await crypto.subtle.importKey(\n    'raw',\n    secretBuffer,\n    CRYPTO_DEFAULT_DERIVE_ALG,\n    false,\n    ['deriveKey'],\n  )\n  return await crypto.subtle.deriveKey(\n    {\n      name: CRYPTO_DEFAULT_DERIVE_ALG,\n      salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),\n      iterations: opt.iterations ?? CRYPTO_DEFAULT_DERIVE_ITERATIONS,\n      hash: CRYPTO_DEFAULT_HASH_ALG,\n    },\n    keyMaterial,\n    {\n      name: CRYPTO_DEFAULT_ALG,\n      length: 256,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  )\n}\n\nexport async function deriveKeyPbkdf2CBC(\n  secret: BinInput,\n  opt: {\n    iterations?: number\n    salt?: BinInput\n  } = {},\n): Promise<CryptoKey> {\n  const secretBuffer = ensureUint8Array(toUint8Array(secret))\n  const keyMaterial = await crypto.subtle.importKey(\n    'raw',\n    secretBuffer,\n    CRYPTO_DEFAULT_DERIVE_ALG,\n    false,\n    ['deriveKey'],\n  )\n  return await crypto.subtle.deriveKey(\n    {\n      name: CRYPTO_DEFAULT_DERIVE_ALG,\n      salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),\n      iterations: opt.iterations ?? CRYPTO_DEFAULT_DERIVE_ITERATIONS,\n      hash: CRYPTO_DEFAULT_HASH_ALG,\n    },\n    keyMaterial,\n    {\n      name: 'AES-CBC',\n      length: 256,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  )\n}\n\nfunction getMagicId() {\n  return new Uint8Array([1, 1])\n}\n\nexport async function encrypt(\n  data: Uint8Array,\n  key: CryptoKey,\n): Promise<Uint8Array> {\n  const MAGIC_ID = getMagicId()\n  const iv = randomUint8Array(CRYPTO_DEFAULT_IV_LENGTH)\n  const cipher = await crypto.subtle.encrypt(\n    { name: CRYPTO_DEFAULT_ALG, iv: ensureUint8Array(iv) },\n    key,\n    ensureUint8Array(data),\n  )\n  const binCypher = new Uint8Array(cipher)\n  const bufferLength = MAGIC_ID.length + iv.length + binCypher.length\n  const buffer = new Uint8Array(bufferLength)\n  let pos = 0\n  buffer.set(MAGIC_ID, pos)\n  pos += MAGIC_ID.length\n  buffer.set(iv, pos)\n  pos += iv.length\n  buffer.set(binCypher, pos)\n  return buffer\n}\n\nexport async function decrypt(\n  data: Uint8Array,\n  key: CryptoKey,\n): Promise<Uint8Array> {\n  const magic = ensureUint8Array(data.subarray(0, 2))\n  if (!equalBinary(magic, getMagicId()))\n    return Promise.reject(new Error(`Unknown magic ${magic}`))\n\n  const iv = ensureUint8Array(data.subarray(2, 2 + CRYPTO_DEFAULT_IV_LENGTH))\n  const cipher = ensureUint8Array(data.subarray(2 + CRYPTO_DEFAULT_IV_LENGTH, data.length))\n  const plain = await crypto.subtle.decrypt(\n    { name: CRYPTO_DEFAULT_ALG, iv },\n    key,\n    cipher,\n  )\n  return new Uint8Array(plain)\n}\n"],"mappings":"yDAIA,SAAgB,EAAiB,EAAS,GAAgB,CACxD,IAAM,EAAc,IAAI,WAAW,EAAO,CAC1C,GAAI,OAAO,OAAW,KAAe,OAAO,gBAC1C,OAAO,gBAAgB,EAAY,MAKnC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAG1B,EAAY,GAAK,KAAK,MAAM,KAAK,QAAQ,CAAG,IAAM,CAGtD,OAAO,EAGT,MAAa,EAA0B,UAC1B,EAAqB,UACrB,EAA4B,SAC5B,EAAmC,IACnC,EAA2B,GAExC,eAAsB,EACpB,EACA,EAAiC,EACZ,CACrB,IAAM,EAAI,EAAiB,EAAa,EAAQ,CAAC,CACjD,OAAO,EACL,MAAM,OAAO,OAAO,OAAO,EAAW,EAAE,CACzC,CAGH,eAAsB,EACpB,EACA,EAGI,EAAE,CACc,CACpB,IAAM,EAAe,EAAiB,EAAa,EAAO,CAAC,CACrD,EAAc,MAAM,OAAO,OAAO,UACtC,MACA,EACA,EACA,GACA,CAAC,YAAY,CACd,CACD,OAAO,MAAM,OAAO,OAAO,UACzB,CACE,KAAM,EACN,KAAM,EAAI,KAAO,EAAiB,EAAa,EAAI,KAAK,CAAC,CAAG,IAAI,WAChE,WAAY,EAAI,YAAA,IAChB,KAAM,EACP,CACD,EACA,CACE,KAAM,EACN,OAAQ,IACT,CACD,GACA,CAAC,UAAW,UAAU,CACvB,CAGH,eAAsB,EACpB,EACA,EAGI,EAAE,CACc,CACpB,IAAM,EAAe,EAAiB,EAAa,EAAO,CAAC,CACrD,EAAc,MAAM,OAAO,OAAO,UACtC,MACA,EACA,EACA,GACA,CAAC,YAAY,CACd,CACD,OAAO,MAAM,OAAO,OAAO,UACzB,CACE,KAAM,EACN,KAAM,EAAI,KAAO,EAAiB,EAAa,EAAI,KAAK,CAAC,CAAG,IAAI,WAChE,WAAY,EAAI,YAAA,IAChB,KAAM,EACP,CACD,EACA,CACE,KAAM,UACN,OAAQ,IACT,CACD,GACA,CAAC,UAAW,UAAU,CACvB,CAGH,SAAS,GAAa,CACpB,OAAO,IAAI,WAAW,CAAC,EAAG,EAAE,CAAC,CAG/B,eAAsB,EACpB,EACA,EACqB,CACrB,IAAM,EAAW,GAAY,CACvB,EAAK,EAAA,GAA0C,CAC/C,EAAS,MAAM,OAAO,OAAO,QACjC,CAAE,KAAM,EAAoB,GAAI,EAAiB,EAAG,CAAE,CACtD,EACA,EAAiB,EAAK,CACvB,CACK,EAAY,IAAI,WAAW,EAAO,CAClC,EAAe,EAAS,OAAS,EAAG,OAAS,EAAU,OACvD,EAAS,IAAI,WAAW,EAAa,CACvC,EAAM,EAMV,OALA,EAAO,IAAI,EAAU,EAAI,CACzB,GAAO,EAAS,OAChB,EAAO,IAAI,EAAI,EAAI,CACnB,GAAO,EAAG,OACV,EAAO,IAAI,EAAW,EAAI,CACnB,EAGT,eAAsB,EACpB,EACA,EACqB,CACrB,IAAM,EAAQ,EAAiB,EAAK,SAAS,EAAG,EAAE,CAAC,CACnD,GAAI,CAAC,EAAY,EAAO,GAAY,CAAC,CACnC,OAAO,QAAQ,OAAW,MAAM,iBAAiB,IAAQ,CAAC,CAE5D,IAAM,EAAK,EAAiB,EAAK,SAAS,EAAG,GAA6B,CAAC,CACrE,EAAS,EAAiB,EAAK,SAAS,GAA8B,EAAK,OAAO,CAAC,CACnF,EAAQ,MAAM,OAAO,OAAO,QAChC,CAAE,KAAM,EAAoB,KAAI,CAChC,EACA,EACD,CACD,OAAO,IAAI,WAAW,EAAM"}

package/dist/common/crypto/index.cjs

@@ -1,2 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../../chunk-5VHLMAKU.cjs');var _chunkL5IXZXHRcjs = require('../../chunk-L5IXZXHR.cjs');var _chunkLUPESR7Scjs = require('../../chunk-LUPESR7S.cjs');var _chunkA6DSKTWFcjs = require('../../chunk-A6DSKTWF.cjs');require('../../chunk-TNMEWZPW.cjs');require('../../chunk-5RHVNJKM.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.CRYPTO_DEFAULT_ALG = _chunkLUPESR7Scjs.c; exports.CRYPTO_DEFAULT_DERIVE_ALG = _chunkLUPESR7Scjs.d; exports.CRYPTO_DEFAULT_DERIVE_ITERATIONS = _chunkLUPESR7Scjs.e; exports.CRYPTO_DEFAULT_HASH_ALG = _chunkLUPESR7Scjs.b; exports.CRYPTO_DEFAULT_IV_LENGTH = _chunkLUPESR7Scjs.f; exports.decrypt = _chunkLUPESR7Scjs.k; exports.decryptAesGcm = _chunkL5IXZXHRcjs.b; exports.decryptXAES = _chunkA6DSKTWFcjs.b; exports.deriveKeyPbkdf2 = _chunkLUPESR7Scjs.h; exports.deriveKeyPbkdf2CBC = _chunkLUPESR7Scjs.i; exports.digest = _chunkLUPESR7Scjs.g; exports.encrypt = _chunkLUPESR7Scjs.j; exports.encryptAesGcm = _chunkL5IXZXHRcjs.a; exports.encryptXAES = _chunkA6DSKTWFcjs.a; exports.exportKeyXAES = _chunkA6DSKTWFcjs.e; exports.generateKeyXAES = _chunkA6DSKTWFcjs.c; exports.importKeyXAES = _chunkA6DSKTWFcjs.d; exports.randomUint8Array = _chunkLUPESR7Scjs.a;
-//# sourceMappingURL=index.cjs.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./aes-sealed.cjs`),t=require(`./crypto.cjs`),n=require(`./xaes.cjs`);exports.CRYPTO_DEFAULT_ALG=t.CRYPTO_DEFAULT_ALG,exports.CRYPTO_DEFAULT_DERIVE_ALG=t.CRYPTO_DEFAULT_DERIVE_ALG,exports.CRYPTO_DEFAULT_DERIVE_ITERATIONS=t.CRYPTO_DEFAULT_DERIVE_ITERATIONS,exports.CRYPTO_DEFAULT_HASH_ALG=t.CRYPTO_DEFAULT_HASH_ALG,exports.CRYPTO_DEFAULT_IV_LENGTH=t.CRYPTO_DEFAULT_IV_LENGTH,exports.decrypt=t.decrypt,exports.decryptAesGcm=e.decryptAesGcm,exports.decryptXAES=n.decryptXAES,exports.deriveKeyPbkdf2=t.deriveKeyPbkdf2,exports.deriveKeyPbkdf2CBC=t.deriveKeyPbkdf2CBC,exports.digest=t.digest,exports.encrypt=t.encrypt,exports.encryptAesGcm=e.encryptAesGcm,exports.encryptXAES=n.encryptXAES,exports.exportKeyXAES=n.exportKeyXAES,exports.generateKeyXAES=n.generateKeyXAES,exports.importKeyXAES=n.importKeyXAES,exports.randomUint8Array=t.randomUint8Array;

package/dist/common/crypto/index.d.cts

@@ -1,4 +1,4 @@
-export { decryptAesGcm, encryptAesGcm } from './aes-sealed.cjs';
-export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array } from './crypto.cjs';
-export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES } from './xaes.cjs';
-import '../data/bin-types.cjs';
+import { n as encryptAesGcm, t as decryptAesGcm } from "../../aes-sealed-Q4saTGg2.cjs";
+import { a as CRYPTO_DEFAULT_IV_LENGTH, c as deriveKeyPbkdf2CBC, d as randomUint8Array, i as CRYPTO_DEFAULT_HASH_ALG, l as digest, n as CRYPTO_DEFAULT_DERIVE_ALG, o as decrypt, r as CRYPTO_DEFAULT_DERIVE_ITERATIONS, s as deriveKeyPbkdf2, t as CRYPTO_DEFAULT_ALG, u as encrypt } from "../../crypto-C8VaLy62.cjs";
+import { a as importKeyXAES, i as generateKeyXAES, n as encryptXAES, r as exportKeyXAES, t as decryptXAES } from "../../xaes-BuoCo_7y.cjs";
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, decryptAesGcm, decryptXAES, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, encryptAesGcm, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES, randomUint8Array };

package/dist/common/crypto/index.d.mts

@@ -0,0 +1,4 @@
+import { n as encryptAesGcm, t as decryptAesGcm } from "../../aes-sealed-CEgjlCzA.mjs";
+import { a as CRYPTO_DEFAULT_IV_LENGTH, c as deriveKeyPbkdf2CBC, d as randomUint8Array, i as CRYPTO_DEFAULT_HASH_ALG, l as digest, n as CRYPTO_DEFAULT_DERIVE_ALG, o as decrypt, r as CRYPTO_DEFAULT_DERIVE_ITERATIONS, s as deriveKeyPbkdf2, t as CRYPTO_DEFAULT_ALG, u as encrypt } from "../../crypto-D4uSzFEL.mjs";
+import { a as importKeyXAES, i as generateKeyXAES, n as encryptXAES, r as exportKeyXAES, t as decryptXAES } from "../../xaes-CTLXxroU.mjs";
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, decryptAesGcm, decryptXAES, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, encryptAesGcm, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES, randomUint8Array };

package/dist/common/crypto/index.mjs

@@ -0,0 +1 @@
+import{decryptAesGcm as e,encryptAesGcm as t}from"./aes-sealed.mjs";import{CRYPTO_DEFAULT_ALG as n,CRYPTO_DEFAULT_DERIVE_ALG as r,CRYPTO_DEFAULT_DERIVE_ITERATIONS as i,CRYPTO_DEFAULT_HASH_ALG as a,CRYPTO_DEFAULT_IV_LENGTH as o,decrypt as s,deriveKeyPbkdf2 as c,deriveKeyPbkdf2CBC as l,digest as u,encrypt as d,randomUint8Array as f}from"./crypto.mjs";import{decryptXAES as p,encryptXAES as m,exportKeyXAES as h,generateKeyXAES as g,importKeyXAES as _}from"./xaes.mjs";export{n as CRYPTO_DEFAULT_ALG,r as CRYPTO_DEFAULT_DERIVE_ALG,i as CRYPTO_DEFAULT_DERIVE_ITERATIONS,a as CRYPTO_DEFAULT_HASH_ALG,o as CRYPTO_DEFAULT_IV_LENGTH,s as decrypt,e as decryptAesGcm,p as decryptXAES,c as deriveKeyPbkdf2,l as deriveKeyPbkdf2CBC,u as digest,d as encrypt,t as encryptAesGcm,m as encryptXAES,h as exportKeyXAES,g as generateKeyXAES,_ as importKeyXAES,f as randomUint8Array};

package/dist/common/crypto/xaes.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkA6DSKTWFcjs = require('../../chunk-A6DSKTWF.cjs');require('../../chunk-TNMEWZPW.cjs');require('../../chunk-5RHVNJKM.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.decryptXAES = _chunkA6DSKTWFcjs.b; exports.encryptXAES = _chunkA6DSKTWFcjs.a; exports.exportKeyXAES = _chunkA6DSKTWFcjs.e; exports.generateKeyXAES = _chunkA6DSKTWFcjs.c; exports.importKeyXAES = _chunkA6DSKTWFcjs.d;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../bin-Ce3i6ABn.cjs`);async function t(e,t,n){let r=await crypto.subtle.encrypt({name:`AES-CBC`,iv:n},e,t);return new Uint8Array(r,0,16)}async function n(n,r,i,a){let o=new Uint8Array(16);return o[1]=n,o[2]=88,o.set(e.o(i.subarray(0,12)),4),await t(r,o,e.o(a))}async function r(r,i){if(r.algorithm.name!==`AES-CBC`)throw Error(`key must be for AES-CBC`);if(!r.usages.includes(`encrypt`))throw Error(`key must have 'encrypt' usage`);if(r.algorithm.length!==256)throw Error(`key must be 256 bits`);if(i==null||i.byteLength!==24)throw Error(`iv must be 24 bytes`);let a=ArrayBuffer.isView(i)?new Uint8Array(i.buffer,i.byteOffset,i.byteLength):new Uint8Array(i),o=await t(r,new Uint8Array(16),new Uint8Array(16)),s=0;for(let e=o.length-1;e>=0;e--)[s,o[e]]=[o[e]>>>7&255,(o[e]<<1|s)&255];o[o.length-1]^=s*135&255;let c=new Uint8Array(32);return c.set(await n(1,r,a,o),0),c.set(await n(2,r,a,o),16),{key:await crypto.subtle.importKey(`raw`,c,{name:`AES-GCM`,length:256},!1,[...r.usages]),iv:e.o(a.subarray(12))}}async function i(e,t,n){let i=await r(t,e.iv);return await crypto.subtle.encrypt({name:`AES-GCM`,iv:i.iv,tagLength:128,additionalData:e.additionalData??new Uint8Array},i.key,n)}async function a(e,t,n){let i=await r(t,e.iv);return await crypto.subtle.decrypt({name:`AES-GCM`,iv:i.iv,tagLength:128,additionalData:e.additionalData??new Uint8Array},i.key,n)}async function o(e){return await crypto.subtle.generateKey({name:`AES-CBC`,length:256},e,[`encrypt`,`decrypt`])}async function s(e,t,n){return await crypto.subtle.importKey(e,t,{name:`AES-CBC`,length:256},n,[`encrypt`,`decrypt`])}async function c(e,t){return await crypto.subtle.exportKey(e,t)}exports.decryptXAES=a,exports.encryptXAES=i,exports.exportKeyXAES=c,exports.generateKeyXAES=o,exports.importKeyXAES=s;
 //# sourceMappingURL=xaes.cjs.map

package/dist/common/crypto/xaes.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/crypto/xaes.cjs"],"names":[],"mappings":"AAAA,qIAA+C,oCAAiC,oCAAiC,oCAAiC,8NAAqG","file":"/Users/dirk/work/github-zeed/dist/common/crypto/xaes.cjs"}
+{"version":3,"file":"xaes.cjs","names":["ensureUint8Array"],"sources":["../../../src/common/crypto/xaes.ts"],"sourcesContent":["// Original at https://github.com/dchest/xaes MIT License as of 2024-07-02\n// More at https://words.filippo.io/dispatches/xaes-256-gcm/\n\nimport { ensureUint8Array } from '../data/bin'\n\n/**\n * Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM\n * based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).\n *\n * It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive\n * a 256-bit key and a 96-bit nonce for AES-GCM.\n *\n * Due to the use of the standard CryptoKey and Web Cryptography API operations,\n * this implementation is fully compatible with other parts of the Web Cryptography API.\n * For example, keys can be stored in IndexedDB and be non-extractable. The only\n * additional requirement is that the key must have 'encrypt' usage even for decryption,\n * however, there's no real distinction between encryption and decryption operations\n * for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).\n */\n\n/**\n * Generates an AES block using the given key and data xored with the given xor.\n */\nasync function aesBlock(key: CryptoKey, data: BufferSource, xor: BufferSource): Promise<Uint8Array> {\n  const block = await crypto.subtle.encrypt(\n    { name: 'AES-CBC', iv: xor },\n    key,\n    data,\n  )\n  return new Uint8Array(block, 0, 16)\n}\n\n/**\n * Derives a half key.\n */\nasync function halfKey(index: number, key: CryptoKey, iv: Uint8Array, k1: Uint8Array): Promise<Uint8Array> {\n  const m = new Uint8Array(16)\n  m[1] = index\n  m[2] = 0x58 // 'X'\n  m.set(ensureUint8Array(iv.subarray(0, 12)), 4)\n  return await aesBlock(key, m, ensureUint8Array(k1))\n}\n\n/**\n * Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.\n */\nasync function deriveKeyNonce(key: CryptoKey, iv: BufferSource): Promise<{ key: CryptoKey, iv: Uint8Array }> {\n  if (key.algorithm.name !== 'AES-CBC') {\n    throw new Error('key must be for AES-CBC')\n  }\n  if (!key.usages.includes('encrypt')) {\n    throw new Error('key must have \\'encrypt\\' usage')\n  }\n  // @ts-expect-error todo\n  if (key.algorithm.length !== 256) {\n    throw new Error('key must be 256 bits')\n  }\n  if (iv == null || iv.byteLength !== 24) {\n    throw new Error('iv must be 24 bytes')\n  }\n  const ivBytes = ArrayBuffer.isView(iv)\n    ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength)\n    : new Uint8Array(iv)\n  const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16))\n\n  let msb = 0\n  for (let i = k1.length - 1; i >= 0; i--) {\n    [msb, k1[i]] = [(k1[i] >>> 7) & 0xFF, ((k1[i] << 1) | msb) & 0xFF]\n  }\n  k1[k1.length - 1] ^= (msb * 0b10000111) & 0xFF\n\n  const kxBytes = new Uint8Array(32)\n  kxBytes.set(await halfKey(0x01, key, ivBytes, k1), 0)\n  kxBytes.set(await halfKey(0x02, key, ivBytes, k1), 16)\n\n  const kx = await crypto.subtle.importKey(\n    'raw',\n    kxBytes,\n    { name: 'AES-GCM', length: 256 },\n    false,\n    [...key.usages],\n  )\n  return {\n    key: kx,\n    iv: ensureUint8Array(ivBytes.subarray(12)),\n  }\n}\n/**\n * Encrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.\n */\nexport async function encryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Decrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.\n */\nexport async function decryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Generate a random key suitable for XAES-256-GCM.\n * The actual key is an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.\n */\nexport async function generateKeyXAES(extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.generateKey(\n    {\n      name: 'AES-CBC',\n      // @ts-expect-error todo\n      length: 256,\n    },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Import a key suitable for XAES-256-GCM.\n * The actual key must be an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.\n */\nexport async function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.importKey( // @ts-expect-error-next-line\n    format,\n    keyData,\n    { name: 'AES-CBC', length: 256 },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Export a key.\n * The resulting export will have AES-CBC algorithm specified.\n *\n * This function is not necessary, as you can use crypto.subtle.exportKey directly.\n */\nexport async function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {\n  return await crypto.subtle.exportKey(format, key)\n}\n"],"mappings":"6GAuBA,eAAe,EAAS,EAAgB,EAAoB,EAAwC,CAClG,IAAM,EAAQ,MAAM,OAAO,OAAO,QAChC,CAAE,KAAM,UAAW,GAAI,EAAK,CAC5B,EACA,EACD,CACD,OAAO,IAAI,WAAW,EAAO,EAAG,GAAG,CAMrC,eAAe,EAAQ,EAAe,EAAgB,EAAgB,EAAqC,CACzG,IAAM,EAAI,IAAI,WAAW,GAAG,CAI5B,MAHA,GAAE,GAAK,EACP,EAAE,GAAK,GACP,EAAE,IAAIA,EAAAA,EAAiB,EAAG,SAAS,EAAG,GAAG,CAAC,CAAE,EAAE,CACvC,MAAM,EAAS,EAAK,EAAGA,EAAAA,EAAiB,EAAG,CAAC,CAMrD,eAAe,EAAe,EAAgB,EAA+D,CAC3G,GAAI,EAAI,UAAU,OAAS,UACzB,MAAU,MAAM,0BAA0B,CAE5C,GAAI,CAAC,EAAI,OAAO,SAAS,UAAU,CACjC,MAAU,MAAM,gCAAkC,CAGpD,GAAI,EAAI,UAAU,SAAW,IAC3B,MAAU,MAAM,uBAAuB,CAEzC,GAAI,GAAM,MAAQ,EAAG,aAAe,GAClC,MAAU,MAAM,sBAAsB,CAExC,IAAM,EAAU,YAAY,OAAO,EAAG,CAClC,IAAI,WAAW,EAAG,OAAQ,EAAG,WAAY,EAAG,WAAW,CACvD,IAAI,WAAW,EAAG,CAChB,EAAK,MAAM,EAAS,EAAK,IAAI,WAAW,GAAG,CAAE,IAAI,WAAW,GAAG,CAAC,CAElE,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,OAAS,EAAG,GAAK,EAAG,IAClC,CAAC,EAAK,EAAG,IAAM,CAAE,EAAG,KAAO,EAAK,KAAQ,EAAG,IAAM,EAAK,GAAO,IAAK,CAEpE,EAAG,EAAG,OAAS,IAAO,EAAM,IAAc,IAE1C,IAAM,EAAU,IAAI,WAAW,GAAG,CAWlC,OAVA,EAAQ,IAAI,MAAM,EAAQ,EAAM,EAAK,EAAS,EAAG,CAAE,EAAE,CACrD,EAAQ,IAAI,MAAM,EAAQ,EAAM,EAAK,EAAS,EAAG,CAAE,GAAG,CAS/C,CACL,IARS,MAAM,OAAO,OAAO,UAC7B,MACA,EACA,CAAE,KAAM,UAAW,OAAQ,IAAK,CAChC,GACA,CAAC,GAAG,EAAI,OAAO,CAChB,CAGC,GAAIA,EAAAA,EAAiB,EAAQ,SAAS,GAAG,CAAC,CAC3C,CAMH,eAAsB,EAAY,EAG/B,EAAgB,EAA0C,CAC3D,IAAM,EAAU,MAAM,EAAe,EAAK,EAAO,GAAG,CACpD,OAAO,MAAM,OAAO,OAAO,QACzB,CACE,KAAM,UACN,GAAI,EAAQ,GACZ,UAAW,IACX,eAAgB,EAAO,gBAAkB,IAAI,WAC9C,CACD,EAAQ,IACR,EACD,CAOH,eAAsB,EAAY,EAG/B,EAAgB,EAA0C,CAC3D,IAAM,EAAU,MAAM,EAAe,EAAK,EAAO,GAAG,CACpD,OAAO,MAAM,OAAO,OAAO,QACzB,CACE,KAAM,UACN,GAAI,EAAQ,GACZ,UAAW,IACX,eAAgB,EAAO,gBAAkB,IAAI,WAC9C,CACD,EAAQ,IACR,EACD,CASH,eAAsB,EAAgB,EAA2C,CAC/E,OAAO,MAAM,OAAO,OAAO,YACzB,CACE,KAAM,UAEN,OAAQ,IACT,CACD,EACA,CAAC,UAAW,UAAU,CACvB,CASH,eAAsB,EAAc,EAA0C,EAAoC,EAA2C,CAC3J,OAAO,MAAM,OAAO,OAAO,UACzB,EACA,EACA,CAAE,KAAM,UAAW,OAAQ,IAAK,CAChC,EACA,CAAC,UAAW,UAAU,CACvB,CASH,eAAsB,EAAc,EAA0C,EAAmD,CAC/H,OAAO,MAAM,OAAO,OAAO,UAAU,EAAQ,EAAI"}

package/dist/common/crypto/xaes.d.cts

@@ -1,39 +1,2 @@
-/**
- * Encrypts data using XAES-256-GCM with the given key and iv.
- * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.
- */
-declare function encryptXAES(params: {
-    iv: BufferSource;
-    additionalData?: BufferSource;
-}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
-/**
- * Decrypts data using XAES-256-GCM with the given key and iv.
- * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.
- */
-declare function decryptXAES(params: {
-    iv: BufferSource;
-    additionalData?: BufferSource;
-}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
-/**
- * Generate a random key suitable for XAES-256-GCM.
- * The actual key is an AES-CBC CryptoKey with 256-bit length.
- *
- * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.
- */
-declare function generateKeyXAES(extractable?: boolean): Promise<CryptoKey>;
-/**
- * Import a key suitable for XAES-256-GCM.
- * The actual key must be an AES-CBC CryptoKey with 256-bit length.
- *
- * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.
- */
-declare function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Export a key.
- * The resulting export will have AES-CBC algorithm specified.
- *
- * This function is not necessary, as you can use crypto.subtle.exportKey directly.
- */
-declare function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
-
-export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES };
+import { a as importKeyXAES, i as generateKeyXAES, n as encryptXAES, r as exportKeyXAES, t as decryptXAES } from "../../xaes-BuoCo_7y.cjs";
+export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES };

package/dist/common/crypto/xaes.d.mts

@@ -0,0 +1,2 @@
+import { a as importKeyXAES, i as generateKeyXAES, n as encryptXAES, r as exportKeyXAES, t as decryptXAES } from "../../xaes-CTLXxroU.mjs";
+export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES };

package/dist/common/crypto/xaes.mjs

@@ -0,0 +1,2 @@
+import{o as e}from"../../bin-SPdenYkw.mjs";async function t(e,t,n){let r=await crypto.subtle.encrypt({name:`AES-CBC`,iv:n},e,t);return new Uint8Array(r,0,16)}async function n(n,r,i,a){let o=new Uint8Array(16);return o[1]=n,o[2]=88,o.set(e(i.subarray(0,12)),4),await t(r,o,e(a))}async function r(r,i){if(r.algorithm.name!==`AES-CBC`)throw Error(`key must be for AES-CBC`);if(!r.usages.includes(`encrypt`))throw Error(`key must have 'encrypt' usage`);if(r.algorithm.length!==256)throw Error(`key must be 256 bits`);if(i==null||i.byteLength!==24)throw Error(`iv must be 24 bytes`);let a=ArrayBuffer.isView(i)?new Uint8Array(i.buffer,i.byteOffset,i.byteLength):new Uint8Array(i),o=await t(r,new Uint8Array(16),new Uint8Array(16)),s=0;for(let e=o.length-1;e>=0;e--)[s,o[e]]=[o[e]>>>7&255,(o[e]<<1|s)&255];o[o.length-1]^=s*135&255;let c=new Uint8Array(32);return c.set(await n(1,r,a,o),0),c.set(await n(2,r,a,o),16),{key:await crypto.subtle.importKey(`raw`,c,{name:`AES-GCM`,length:256},!1,[...r.usages]),iv:e(a.subarray(12))}}async function i(e,t,n){let i=await r(t,e.iv);return await crypto.subtle.encrypt({name:`AES-GCM`,iv:i.iv,tagLength:128,additionalData:e.additionalData??new Uint8Array},i.key,n)}async function a(e,t,n){let i=await r(t,e.iv);return await crypto.subtle.decrypt({name:`AES-GCM`,iv:i.iv,tagLength:128,additionalData:e.additionalData??new Uint8Array},i.key,n)}async function o(e){return await crypto.subtle.generateKey({name:`AES-CBC`,length:256},e,[`encrypt`,`decrypt`])}async function s(e,t,n){return await crypto.subtle.importKey(e,t,{name:`AES-CBC`,length:256},n,[`encrypt`,`decrypt`])}async function c(e,t){return await crypto.subtle.exportKey(e,t)}export{a as decryptXAES,i as encryptXAES,c as exportKeyXAES,o as generateKeyXAES,s as importKeyXAES};
+//# sourceMappingURL=xaes.mjs.map

package/dist/common/crypto/xaes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"xaes.mjs","names":[],"sources":["../../../src/common/crypto/xaes.ts"],"sourcesContent":["// Original at https://github.com/dchest/xaes MIT License as of 2024-07-02\n// More at https://words.filippo.io/dispatches/xaes-256-gcm/\n\nimport { ensureUint8Array } from '../data/bin'\n\n/**\n * Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM\n * based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).\n *\n * It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive\n * a 256-bit key and a 96-bit nonce for AES-GCM.\n *\n * Due to the use of the standard CryptoKey and Web Cryptography API operations,\n * this implementation is fully compatible with other parts of the Web Cryptography API.\n * For example, keys can be stored in IndexedDB and be non-extractable. The only\n * additional requirement is that the key must have 'encrypt' usage even for decryption,\n * however, there's no real distinction between encryption and decryption operations\n * for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).\n */\n\n/**\n * Generates an AES block using the given key and data xored with the given xor.\n */\nasync function aesBlock(key: CryptoKey, data: BufferSource, xor: BufferSource): Promise<Uint8Array> {\n  const block = await crypto.subtle.encrypt(\n    { name: 'AES-CBC', iv: xor },\n    key,\n    data,\n  )\n  return new Uint8Array(block, 0, 16)\n}\n\n/**\n * Derives a half key.\n */\nasync function halfKey(index: number, key: CryptoKey, iv: Uint8Array, k1: Uint8Array): Promise<Uint8Array> {\n  const m = new Uint8Array(16)\n  m[1] = index\n  m[2] = 0x58 // 'X'\n  m.set(ensureUint8Array(iv.subarray(0, 12)), 4)\n  return await aesBlock(key, m, ensureUint8Array(k1))\n}\n\n/**\n * Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.\n */\nasync function deriveKeyNonce(key: CryptoKey, iv: BufferSource): Promise<{ key: CryptoKey, iv: Uint8Array }> {\n  if (key.algorithm.name !== 'AES-CBC') {\n    throw new Error('key must be for AES-CBC')\n  }\n  if (!key.usages.includes('encrypt')) {\n    throw new Error('key must have \\'encrypt\\' usage')\n  }\n  // @ts-expect-error todo\n  if (key.algorithm.length !== 256) {\n    throw new Error('key must be 256 bits')\n  }\n  if (iv == null || iv.byteLength !== 24) {\n    throw new Error('iv must be 24 bytes')\n  }\n  const ivBytes = ArrayBuffer.isView(iv)\n    ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength)\n    : new Uint8Array(iv)\n  const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16))\n\n  let msb = 0\n  for (let i = k1.length - 1; i >= 0; i--) {\n    [msb, k1[i]] = [(k1[i] >>> 7) & 0xFF, ((k1[i] << 1) | msb) & 0xFF]\n  }\n  k1[k1.length - 1] ^= (msb * 0b10000111) & 0xFF\n\n  const kxBytes = new Uint8Array(32)\n  kxBytes.set(await halfKey(0x01, key, ivBytes, k1), 0)\n  kxBytes.set(await halfKey(0x02, key, ivBytes, k1), 16)\n\n  const kx = await crypto.subtle.importKey(\n    'raw',\n    kxBytes,\n    { name: 'AES-GCM', length: 256 },\n    false,\n    [...key.usages],\n  )\n  return {\n    key: kx,\n    iv: ensureUint8Array(ivBytes.subarray(12)),\n  }\n}\n/**\n * Encrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.\n */\nexport async function encryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Decrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.\n */\nexport async function decryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Generate a random key suitable for XAES-256-GCM.\n * The actual key is an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.\n */\nexport async function generateKeyXAES(extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.generateKey(\n    {\n      name: 'AES-CBC',\n      // @ts-expect-error todo\n      length: 256,\n    },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Import a key suitable for XAES-256-GCM.\n * The actual key must be an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.\n */\nexport async function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.importKey( // @ts-expect-error-next-line\n    format,\n    keyData,\n    { name: 'AES-CBC', length: 256 },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Export a key.\n * The resulting export will have AES-CBC algorithm specified.\n *\n * This function is not necessary, as you can use crypto.subtle.exportKey directly.\n */\nexport async function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {\n  return await crypto.subtle.exportKey(format, key)\n}\n"],"mappings":"2CAuBA,eAAe,EAAS,EAAgB,EAAoB,EAAwC,CAClG,IAAM,EAAQ,MAAM,OAAO,OAAO,QAChC,CAAE,KAAM,UAAW,GAAI,EAAK,CAC5B,EACA,EACD,CACD,OAAO,IAAI,WAAW,EAAO,EAAG,GAAG,CAMrC,eAAe,EAAQ,EAAe,EAAgB,EAAgB,EAAqC,CACzG,IAAM,EAAI,IAAI,WAAW,GAAG,CAI5B,MAHA,GAAE,GAAK,EACP,EAAE,GAAK,GACP,EAAE,IAAI,EAAiB,EAAG,SAAS,EAAG,GAAG,CAAC,CAAE,EAAE,CACvC,MAAM,EAAS,EAAK,EAAG,EAAiB,EAAG,CAAC,CAMrD,eAAe,EAAe,EAAgB,EAA+D,CAC3G,GAAI,EAAI,UAAU,OAAS,UACzB,MAAU,MAAM,0BAA0B,CAE5C,GAAI,CAAC,EAAI,OAAO,SAAS,UAAU,CACjC,MAAU,MAAM,gCAAkC,CAGpD,GAAI,EAAI,UAAU,SAAW,IAC3B,MAAU,MAAM,uBAAuB,CAEzC,GAAI,GAAM,MAAQ,EAAG,aAAe,GAClC,MAAU,MAAM,sBAAsB,CAExC,IAAM,EAAU,YAAY,OAAO,EAAG,CAClC,IAAI,WAAW,EAAG,OAAQ,EAAG,WAAY,EAAG,WAAW,CACvD,IAAI,WAAW,EAAG,CAChB,EAAK,MAAM,EAAS,EAAK,IAAI,WAAW,GAAG,CAAE,IAAI,WAAW,GAAG,CAAC,CAElE,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,OAAS,EAAG,GAAK,EAAG,IAClC,CAAC,EAAK,EAAG,IAAM,CAAE,EAAG,KAAO,EAAK,KAAQ,EAAG,IAAM,EAAK,GAAO,IAAK,CAEpE,EAAG,EAAG,OAAS,IAAO,EAAM,IAAc,IAE1C,IAAM,EAAU,IAAI,WAAW,GAAG,CAWlC,OAVA,EAAQ,IAAI,MAAM,EAAQ,EAAM,EAAK,EAAS,EAAG,CAAE,EAAE,CACrD,EAAQ,IAAI,MAAM,EAAQ,EAAM,EAAK,EAAS,EAAG,CAAE,GAAG,CAS/C,CACL,IARS,MAAM,OAAO,OAAO,UAC7B,MACA,EACA,CAAE,KAAM,UAAW,OAAQ,IAAK,CAChC,GACA,CAAC,GAAG,EAAI,OAAO,CAChB,CAGC,GAAI,EAAiB,EAAQ,SAAS,GAAG,CAAC,CAC3C,CAMH,eAAsB,EAAY,EAG/B,EAAgB,EAA0C,CAC3D,IAAM,EAAU,MAAM,EAAe,EAAK,EAAO,GAAG,CACpD,OAAO,MAAM,OAAO,OAAO,QACzB,CACE,KAAM,UACN,GAAI,EAAQ,GACZ,UAAW,IACX,eAAgB,EAAO,gBAAkB,IAAI,WAC9C,CACD,EAAQ,IACR,EACD,CAOH,eAAsB,EAAY,EAG/B,EAAgB,EAA0C,CAC3D,IAAM,EAAU,MAAM,EAAe,EAAK,EAAO,GAAG,CACpD,OAAO,MAAM,OAAO,OAAO,QACzB,CACE,KAAM,UACN,GAAI,EAAQ,GACZ,UAAW,IACX,eAAgB,EAAO,gBAAkB,IAAI,WAC9C,CACD,EAAQ,IACR,EACD,CASH,eAAsB,EAAgB,EAA2C,CAC/E,OAAO,MAAM,OAAO,OAAO,YACzB,CACE,KAAM,UAEN,OAAQ,IACT,CACD,EACA,CAAC,UAAW,UAAU,CACvB,CASH,eAAsB,EAAc,EAA0C,EAAoC,EAA2C,CAC3J,OAAO,MAAM,OAAO,OAAO,UACzB,EACA,EACA,CAAE,KAAM,UAAW,OAAQ,IAAK,CAChC,EACA,CAAC,UAAW,UAAU,CACvB,CASH,eAAsB,EAAc,EAA0C,EAAmD,CAC/H,OAAO,MAAM,OAAO,OAAO,UAAU,EAAQ,EAAI"}