cborg 2.0.5 → 3.0.0-alpha.1

package/esm/lib/byte-utils.js

@@ -1,228 +0,0 @@
-export const useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === 'function';
-const textDecoder = new TextDecoder();
-const textEncoder = new TextEncoder();
-function isBuffer(buf) {
-  return useBuffer && globalThis.Buffer.isBuffer(buf);
-}
-export function asU8A(buf) {
-  if (!(buf instanceof Uint8Array)) {
-    return Uint8Array.from(buf);
-  }
-  return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
-}
-export const toString = useBuffer ? (bytes, start, end) => {
-  return end - start > 64 ? globalThis.Buffer.from(bytes.subarray(start, end)).toString('utf8') : utf8Slice(bytes, start, end);
-} : (bytes, start, end) => {
-  return end - start > 64 ? textDecoder.decode(bytes.subarray(start, end)) : utf8Slice(bytes, start, end);
-};
-export const fromString = useBuffer ? string => {
-  return string.length > 64 ? globalThis.Buffer.from(string) : utf8ToBytes(string);
-} : string => {
-  return string.length > 64 ? textEncoder.encode(string) : utf8ToBytes(string);
-};
-export const fromArray = arr => {
-  return Uint8Array.from(arr);
-};
-export const slice = useBuffer ? (bytes, start, end) => {
-  if (isBuffer(bytes)) {
-    return new Uint8Array(bytes.subarray(start, end));
-  }
-  return bytes.slice(start, end);
-} : (bytes, start, end) => {
-  return bytes.slice(start, end);
-};
-export const concat = useBuffer ? (chunks, length) => {
-  chunks = chunks.map(c => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
-  return asU8A(globalThis.Buffer.concat(chunks, length));
-} : (chunks, length) => {
-  const out = new Uint8Array(length);
-  let off = 0;
-  for (let b of chunks) {
-    if (off + b.length > out.length) {
-      b = b.subarray(0, out.length - off);
-    }
-    out.set(b, off);
-    off += b.length;
-  }
-  return out;
-};
-export const alloc = useBuffer ? size => {
-  return globalThis.Buffer.allocUnsafe(size);
-} : size => {
-  return new Uint8Array(size);
-};
-export const toHex = useBuffer ? d => {
-  if (typeof d === 'string') {
-    return d;
-  }
-  return globalThis.Buffer.from(toBytes(d)).toString('hex');
-} : d => {
-  if (typeof d === 'string') {
-    return d;
-  }
-  return Array.prototype.reduce.call(toBytes(d), (p, c) => `${ p }${ c.toString(16).padStart(2, '0') }`, '');
-};
-export const fromHex = useBuffer ? hex => {
-  if (hex instanceof Uint8Array) {
-    return hex;
-  }
-  return globalThis.Buffer.from(hex, 'hex');
-} : hex => {
-  if (hex instanceof Uint8Array) {
-    return hex;
-  }
-  if (!hex.length) {
-    return new Uint8Array(0);
-  }
-  return new Uint8Array(hex.split('').map((c, i, d) => i % 2 === 0 ? `0x${ c }${ d[i + 1] }` : '').filter(Boolean).map(e => parseInt(e, 16)));
-};
-function toBytes(obj) {
-  if (obj instanceof Uint8Array && obj.constructor.name === 'Uint8Array') {
-    return obj;
-  }
-  if (obj instanceof ArrayBuffer) {
-    return new Uint8Array(obj);
-  }
-  if (ArrayBuffer.isView(obj)) {
-    return new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength);
-  }
-  throw new Error('Unknown type, must be binary type');
-}
-export function compare(b1, b2) {
-  if (isBuffer(b1) && isBuffer(b2)) {
-    return b1.compare(b2);
-  }
-  for (let i = 0; i < b1.length; i++) {
-    if (b1[i] === b2[i]) {
-      continue;
-    }
-    return b1[i] < b2[i] ? -1 : 1;
-  }
-  return 0;
-}
-function utf8ToBytes(string, units = Infinity) {
-  let codePoint;
-  const length = string.length;
-  let leadSurrogate = null;
-  const bytes = [];
-  for (let i = 0; i < length; ++i) {
-    codePoint = string.charCodeAt(i);
-    if (codePoint > 55295 && codePoint < 57344) {
-      if (!leadSurrogate) {
-        if (codePoint > 56319) {
-          if ((units -= 3) > -1)
-            bytes.push(239, 191, 189);
-          continue;
-        } else if (i + 1 === length) {
-          if ((units -= 3) > -1)
-            bytes.push(239, 191, 189);
-          continue;
-        }
-        leadSurrogate = codePoint;
-        continue;
-      }
-      if (codePoint < 56320) {
-        if ((units -= 3) > -1)
-          bytes.push(239, 191, 189);
-        leadSurrogate = codePoint;
-        continue;
-      }
-      codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
-    } else if (leadSurrogate) {
-      if ((units -= 3) > -1)
-        bytes.push(239, 191, 189);
-    }
-    leadSurrogate = null;
-    if (codePoint < 128) {
-      if ((units -= 1) < 0)
-        break;
-      bytes.push(codePoint);
-    } else if (codePoint < 2048) {
-      if ((units -= 2) < 0)
-        break;
-      bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
-    } else if (codePoint < 65536) {
-      if ((units -= 3) < 0)
-        break;
-      bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
-    } else if (codePoint < 1114112) {
-      if ((units -= 4) < 0)
-        break;
-      bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
-    } else {
-      throw new Error('Invalid code point');
-    }
-  }
-  return bytes;
-}
-function utf8Slice(buf, offset, end) {
-  const res = [];
-  while (offset < end) {
-    const firstByte = buf[offset];
-    let codePoint = null;
-    let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-    if (offset + bytesPerSequence <= end) {
-      let secondByte, thirdByte, fourthByte, tempCodePoint;
-      switch (bytesPerSequence) {
-      case 1:
-        if (firstByte < 128) {
-          codePoint = firstByte;
-        }
-        break;
-      case 2:
-        secondByte = buf[offset + 1];
-        if ((secondByte & 192) === 128) {
-          tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
-          if (tempCodePoint > 127) {
-            codePoint = tempCodePoint;
-          }
-        }
-        break;
-      case 3:
-        secondByte = buf[offset + 1];
-        thirdByte = buf[offset + 2];
-        if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
-          tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
-          if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
-            codePoint = tempCodePoint;
-          }
-        }
-        break;
-      case 4:
-        secondByte = buf[offset + 1];
-        thirdByte = buf[offset + 2];
-        fourthByte = buf[offset + 3];
-        if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
-          tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
-          if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
-            codePoint = tempCodePoint;
-          }
-        }
-      }
-    }
-    if (codePoint === null) {
-      codePoint = 65533;
-      bytesPerSequence = 1;
-    } else if (codePoint > 65535) {
-      codePoint -= 65536;
-      res.push(codePoint >>> 10 & 1023 | 55296);
-      codePoint = 56320 | codePoint & 1023;
-    }
-    res.push(codePoint);
-    offset += bytesPerSequence;
-  }
-  return decodeCodePointsArray(res);
-}
-const MAX_ARGUMENTS_LENGTH = 4096;
-export function decodeCodePointsArray(codePoints) {
-  const len = codePoints.length;
-  if (len <= MAX_ARGUMENTS_LENGTH) {
-    return String.fromCharCode.apply(String, codePoints);
-  }
-  let res = '';
-  let i = 0;
-  while (i < len) {
-    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
-  }
-  return res;
-}

package/esm/lib/common.js

@@ -1,19 +0,0 @@
-const decodeErrPrefix = 'CBOR decode error:';
-const encodeErrPrefix = 'CBOR encode error:';
-const uintMinorPrefixBytes = [];
-uintMinorPrefixBytes[23] = 1;
-uintMinorPrefixBytes[24] = 2;
-uintMinorPrefixBytes[25] = 3;
-uintMinorPrefixBytes[26] = 5;
-uintMinorPrefixBytes[27] = 9;
-function assertEnoughData(data, pos, need) {
-  if (data.length - pos < need) {
-    throw new Error(`${ decodeErrPrefix } not enough data for type`);
-  }
-}
-export {
-  decodeErrPrefix,
-  encodeErrPrefix,
-  uintMinorPrefixBytes,
-  assertEnoughData
-};

package/esm/lib/decode.js

@@ -1,139 +0,0 @@
-import { decodeErrPrefix } from './common.js';
-import { Type } from './token.js';
-import {
-  jump,
-  quick
-} from './jump.js';
-const defaultDecodeOptions = {
-  strict: false,
-  allowIndefinite: true,
-  allowUndefined: true,
-  allowBigInt: true
-};
-class Tokeniser {
-  constructor(data, options = {}) {
-    this.pos = 0;
-    this.data = data;
-    this.options = options;
-  }
-  done() {
-    return this.pos >= this.data.length;
-  }
-  next() {
-    const byt = this.data[this.pos];
-    let token = quick[byt];
-    if (token === undefined) {
-      const decoder = jump[byt];
-      if (!decoder) {
-        throw new Error(`${ decodeErrPrefix } no decoder for major type ${ byt >>> 5 } (byte 0x${ byt.toString(16).padStart(2, '0') })`);
-      }
-      const minor = byt & 31;
-      token = decoder(this.data, this.pos, minor, this.options);
-    }
-    this.pos += token.encodedLength;
-    return token;
-  }
-}
-const DONE = Symbol.for('DONE');
-const BREAK = Symbol.for('BREAK');
-function tokenToArray(token, tokeniser, options) {
-  const arr = [];
-  for (let i = 0; i < token.value; i++) {
-    const value = tokensToObject(tokeniser, options);
-    if (value === BREAK) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${ decodeErrPrefix } got unexpected break to lengthed array`);
-    }
-    if (value === DONE) {
-      throw new Error(`${ decodeErrPrefix } found array but not enough entries (got ${ i }, expected ${ token.value })`);
-    }
-    arr[i] = value;
-  }
-  return arr;
-}
-function tokenToMap(token, tokeniser, options) {
-  const useMaps = options.useMaps === true;
-  const obj = useMaps ? undefined : {};
-  const m = useMaps ? new Map() : undefined;
-  for (let i = 0; i < token.value; i++) {
-    const key = tokensToObject(tokeniser, options);
-    if (key === BREAK) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${ decodeErrPrefix } got unexpected break to lengthed map`);
-    }
-    if (key === DONE) {
-      throw new Error(`${ decodeErrPrefix } found map but not enough entries (got ${ i } [no key], expected ${ token.value })`);
-    }
-    if (useMaps !== true && typeof key !== 'string') {
-      throw new Error(`${ decodeErrPrefix } non-string keys not supported (got ${ typeof key })`);
-    }
-    if (options.rejectDuplicateMapKeys === true) {
-      if (useMaps && m.has(key) || !useMaps && key in obj) {
-        throw new Error(`${ decodeErrPrefix } found repeat map key "${ key }"`);
-      }
-    }
-    const value = tokensToObject(tokeniser, options);
-    if (value === DONE) {
-      throw new Error(`${ decodeErrPrefix } found map but not enough entries (got ${ i } [no value], expected ${ token.value })`);
-    }
-    if (useMaps) {
-      m.set(key, value);
-    } else {
-      obj[key] = value;
-    }
-  }
-  return useMaps ? m : obj;
-}
-function tokensToObject(tokeniser, options) {
-  if (tokeniser.done()) {
-    return DONE;
-  }
-  const token = tokeniser.next();
-  if (token.type === Type.break) {
-    return BREAK;
-  }
-  if (token.type.terminal) {
-    return token.value;
-  }
-  if (token.type === Type.array) {
-    return tokenToArray(token, tokeniser, options);
-  }
-  if (token.type === Type.map) {
-    return tokenToMap(token, tokeniser, options);
-  }
-  if (token.type === Type.tag) {
-    if (options.tags && typeof options.tags[token.value] === 'function') {
-      const tagged = tokensToObject(tokeniser, options);
-      return options.tags[token.value](tagged);
-    }
-    throw new Error(`${ decodeErrPrefix } tag not supported (${ token.value })`);
-  }
-  throw new Error('unsupported');
-}
-function decode(data, options) {
-  if (!(data instanceof Uint8Array)) {
-    throw new Error(`${ decodeErrPrefix } data to decode must be a Uint8Array`);
-  }
-  options = Object.assign({}, defaultDecodeOptions, options);
-  const tokeniser = options.tokenizer || new Tokeniser(data, options);
-  const decoded = tokensToObject(tokeniser, options);
-  if (decoded === DONE) {
-    throw new Error(`${ decodeErrPrefix } did not find any content to decode`);
-  }
-  if (decoded === BREAK) {
-    throw new Error(`${ decodeErrPrefix } got unexpected break`);
-  }
-  if (!tokeniser.done()) {
-    throw new Error(`${ decodeErrPrefix } too many terminals, data makes no sense`);
-  }
-  return decoded;
-}
-export {
-  Tokeniser,
-  tokensToObject,
-  decode
-};

package/esm/lib/diagnostic.js

@@ -1,123 +0,0 @@
-import { Tokeniser } from './decode.js';
-import {
-  toHex,
-  fromHex
-} from './byte-utils.js';
-import { uintBoundaries } from './0uint.js';
-const utf8Encoder = new TextEncoder();
-const utf8Decoder = new TextDecoder();
-function* tokensToDiagnostic(inp, width = 100) {
-  const tokeniser = new Tokeniser(inp, {
-    retainStringBytes: true,
-    allowBigInt: true
-  });
-  let pos = 0;
-  const indent = [];
-  const slc = (start, length) => {
-    return toHex(inp.slice(pos + start, pos + start + length));
-  };
-  while (!tokeniser.done()) {
-    const token = tokeniser.next();
-    let margin = ''.padStart(indent.length * 2, ' ');
-    let vLength = token.encodedLength - 1;
-    let v = String(token.value);
-    let outp = `${ margin }${ slc(0, 1) }`;
-    const str = token.type.name === 'bytes' || token.type.name === 'string';
-    if (token.type.name === 'string') {
-      v = v.length;
-      vLength -= v;
-    } else if (token.type.name === 'bytes') {
-      v = token.value.length;
-      vLength -= v;
-    }
-    let multilen;
-    switch (token.type.name) {
-    case 'string':
-    case 'bytes':
-    case 'map':
-    case 'array':
-      multilen = token.type.name === 'string' ? utf8Encoder.encode(token.value).length : token.value.length;
-      if (multilen >= uintBoundaries[0]) {
-        if (multilen < uintBoundaries[1]) {
-          outp += ` ${ slc(1, 1) }`;
-        } else if (multilen < uintBoundaries[2]) {
-          outp += ` ${ slc(1, 2) }`;
-        } else if (multilen < uintBoundaries[3]) {
-          outp += ` ${ slc(1, 4) }`;
-        } else if (multilen < uintBoundaries[4]) {
-          outp += ` ${ slc(1, 8) }`;
-        }
-      }
-      break;
-    default:
-      outp += ` ${ slc(1, vLength) }`;
-      break;
-    }
-    outp = outp.padEnd(width / 2, ' ');
-    outp += `# ${ margin }${ token.type.name }`;
-    if (token.type.name !== v) {
-      outp += `(${ v })`;
-    }
-    yield outp;
-    if (str) {
-      let asString = token.type.name === 'string';
-      margin += '  ';
-      let repr = asString ? utf8Encoder.encode(token.value) : token.value;
-      if (asString && token.byteValue !== undefined) {
-        if (repr.length !== token.byteValue.length) {
-          repr = token.byteValue;
-          asString = false;
-        }
-      }
-      const wh = (width / 2 - margin.length - 1) / 2;
-      let snip = 0;
-      while (repr.length - snip > 0) {
-        const piece = repr.slice(snip, snip + wh);
-        snip += piece.length;
-        const st = asString ? utf8Decoder.decode(piece) : piece.reduce((p, c) => {
-          if (c < 32 || c >= 127 && c < 161 || c === 173) {
-            return `${ p }\\x${ c.toString(16).padStart(2, '0') }`;
-          }
-          return `${ p }${ String.fromCharCode(c) }`;
-        }, '');
-        yield `${ margin }${ toHex(piece) }`.padEnd(width / 2, ' ') + `# ${ margin }"${ st }"`;
-      }
-    }
-    if (indent.length) {
-      indent[indent.length - 1]--;
-    }
-    if (!token.type.terminal) {
-      switch (token.type.name) {
-      case 'map':
-        indent.push(token.value * 2);
-        break;
-      case 'array':
-        indent.push(token.value);
-        break;
-      case 'tag':
-        indent.push(1);
-        break;
-      default:
-        throw new Error(`Unknown token type '${ token.type.name }'`);
-      }
-    }
-    while (indent.length && indent[indent.length - 1] <= 0) {
-      indent.pop();
-    }
-    pos += token.encodedLength;
-  }
-}
-function fromDiag(input) {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected string input');
-  }
-  input = input.replace(/#.*?$/mg, '').replace(/[\s\r\n]+/mg, '');
-  if (/[^a-f0-9]/i.test(input)) {
-    throw new TypeError('Input string was not CBOR diagnostic format');
-  }
-  return fromHex(input);
-}
-export {
-  tokensToDiagnostic,
-  fromDiag
-};