@songtonyli/dsh-cli 0.1.12 → 0.1.14

package/node_modules/restructure/index.js

@@ -0,0 +1,17 @@
+export {EncodeStream} from './src/EncodeStream.js';
+export {DecodeStream} from './src/DecodeStream.js';
+export {Array} from './src/Array.js';
+export {LazyArray} from './src/LazyArray.js';
+export {Bitfield} from './src/Bitfield.js';
+export {Boolean} from './src/Boolean.js';
+export {Buffer} from './src/Buffer.js';
+export {Enum} from './src/Enum.js';
+export {Optional} from './src/Optional.js';
+export {Reserved} from './src/Reserved.js';
+export {String} from './src/String.js';
+export {Struct} from './src/Struct.js';
+export {VersionedStruct} from './src/VersionedStruct.js';
+
+export * from './src/utils.js';
+export * from './src/Number.js';
+export * from './src/Pointer.js';

package/node_modules/restructure/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "restructure",
+  "version": "3.0.2",
+  "description": "Declaratively encode and decode binary data",
+  "type": "module",
+  "main": "./dist/main.cjs",
+  "module": "./index.js",
+  "source": "./index.js",
+  "exports": {
+    "import": "./index.js",
+    "require": "./dist/main.cjs"
+  },
+  "targets": {
+    "module": false
+  },
+  "devDependencies": {
+    "mocha": "^10.0.0",
+    "parcel": "^2.6.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/devongovett/restructure.git"
+  },
+  "keywords": [
+    "binary",
+    "struct",
+    "encode",
+    "decode"
+  ],
+  "author": "Devon Govett <devongovett@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/devongovett/restructure/issues"
+  },
+  "homepage": "https://github.com/devongovett/restructure"
+}

package/node_modules/restructure/src/Array.js

@@ -0,0 +1,106 @@
+import {Base} from './Base.js';
+import {Number as NumberT} from './Number.js';
+import * as utils from './utils.js';
+
+class ArrayT extends Base {
+  constructor(type, length, lengthType = 'count') {
+    super();
+    this.type = type;
+    this.length = length;
+    this.lengthType = lengthType;
+  }
+
+  decode(stream, parent) {
+    let length;
+    const { pos } = stream;
+
+    const res = [];
+    let ctx = parent;
+
+    if (this.length != null) {
+      length = utils.resolveLength(this.length, stream, parent);
+    }
+
+    if (this.length instanceof NumberT) {
+      // define hidden properties
+      Object.defineProperties(res, {
+        parent:         { value: parent },
+        _startOffset:   { value: pos },
+        _currentOffset: { value: 0, writable: true },
+        _length:        { value: length }
+      });
+
+      ctx = res;
+    }
+
+    if ((length == null) || (this.lengthType === 'bytes')) {
+      const target = (length != null) ?
+        stream.pos + length
+      : (parent != null ? parent._length : undefined) ?
+        parent._startOffset + parent._length
+      :
+        stream.length;
+
+      while (stream.pos < target) {
+        res.push(this.type.decode(stream, ctx));
+      }
+
+    } else {
+      for (let i = 0, end = length; i < end; i++) {
+        res.push(this.type.decode(stream, ctx));
+      }
+    }
+
+    return res;
+  }
+
+  size(array, ctx, includePointers = true) {
+    if (!array) {
+      return this.type.size(null, ctx) * utils.resolveLength(this.length, null, ctx);
+    }
+
+    let size = 0;
+    if (this.length instanceof NumberT) {
+      size += this.length.size();
+      ctx = {parent: ctx, pointerSize: 0};
+    }
+
+    for (let item of array) {
+      size += this.type.size(item, ctx);
+    }
+
+    if (ctx && includePointers && this.length instanceof NumberT) {
+      size += ctx.pointerSize;
+    }
+    
+    return size;
+  }
+
+  encode(stream, array, parent) {
+    let ctx = parent;
+    if (this.length instanceof NumberT) {
+      ctx = {
+        pointers: [],
+        startOffset: stream.pos,
+        parent
+      };
+
+      ctx.pointerOffset = stream.pos + this.size(array, ctx, false);
+      this.length.encode(stream, array.length);
+    }
+
+    for (let item of array) {
+      this.type.encode(stream, item, ctx);
+    }
+
+    if (this.length instanceof NumberT) {
+      let i = 0;
+      while (i < ctx.pointers.length) {
+        const ptr = ctx.pointers[i++];
+        ptr.type.encode(stream, ptr.val, ptr.parent);
+      }
+    }
+  }
+}
+
+export {ArrayT as Array};

package/node_modules/restructure/src/Base.js

@@ -0,0 +1,17 @@
+import {DecodeStream} from './DecodeStream.js';
+import {EncodeStream} from './EncodeStream.js';
+
+export class Base {
+  fromBuffer(buffer) {
+    let stream = new DecodeStream(buffer);
+    return this.decode(stream);
+  }
+
+  toBuffer(value) {
+    let size = this.size(value);
+    let buffer = new Uint8Array(size);
+    let stream = new EncodeStream(buffer);
+    this.encode(stream, value);
+    return buffer;
+  }
+}

package/node_modules/restructure/src/Bitfield.js

@@ -0,0 +1,39 @@
+import {Base} from './Base.js';
+
+export class Bitfield extends Base {
+  constructor(type, flags = []) {
+    super();
+    this.type = type;
+    this.flags = flags;
+  }
+
+  decode(stream) {
+    const val = this.type.decode(stream);
+
+    const res = {};
+    for (let i = 0; i < this.flags.length; i++) {
+      const flag = this.flags[i];
+      if (flag != null) {
+        res[flag] = !!(val & (1 << i));
+      }
+    }
+
+    return res;
+  }
+
+  size() {
+    return this.type.size();
+  }
+
+  encode(stream, keys) {
+    let val = 0;
+    for (let i = 0; i < this.flags.length; i++) {
+      const flag = this.flags[i];
+      if (flag != null) {
+        if (keys[flag]) { val |= (1 << i); }
+      }
+    }
+
+    return this.type.encode(stream, val);
+  }
+}

package/node_modules/restructure/src/Boolean.js

@@ -0,0 +1,22 @@
+import {Base} from './Base.js';
+
+export class BooleanT extends Base {
+  constructor(type) {
+    super();
+    this.type = type;
+  }
+
+  decode(stream, parent) {
+    return !!this.type.decode(stream, parent);
+  }
+
+  size(val, parent) {
+    return this.type.size(val, parent);
+  }
+
+  encode(stream, val, parent) {
+    return this.type.encode(stream, +val, parent);
+  }
+}
+
+export {BooleanT as Boolean};

package/node_modules/restructure/src/Buffer.js

@@ -0,0 +1,38 @@
+import {Base} from './Base.js';
+import {Number as NumberT} from './Number.js';
+import * as utils from './utils.js';
+
+export class BufferT extends Base {
+  constructor(length) {
+    super();
+    this.length = length;
+  }
+  
+  decode(stream, parent) {
+    const length = utils.resolveLength(this.length, stream, parent);
+    return stream.readBuffer(length);
+  }
+
+  size(val, parent) {
+    if (!val) {
+      return utils.resolveLength(this.length, null, parent);
+    }
+
+    let len = val.length;
+    if (this.length instanceof NumberT) {
+      len += this.length.size();
+    }
+
+    return len;
+  }
+
+  encode(stream, buf, parent) {
+    if (this.length instanceof NumberT) {
+      this.length.encode(stream, buf.length);
+    }
+
+    return stream.writeBuffer(buf);
+  }
+}
+
+export {BufferT as Buffer};

package/node_modules/restructure/src/DecodeStream.js

@@ -0,0 +1,85 @@
+// Node back-compat.
+const ENCODING_MAPPING = {
+  utf16le: 'utf-16le',
+  ucs2: 'utf-16le',
+  utf16be: 'utf-16be'
+}
+
+export class DecodeStream {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    this.pos = 0;
+    this.length = this.buffer.length;
+  }
+
+  readString(length, encoding = 'ascii') {
+    encoding = ENCODING_MAPPING[encoding] || encoding;
+
+    let buf = this.readBuffer(length);
+    try {
+      let decoder = new TextDecoder(encoding);
+      return decoder.decode(buf);
+    } catch (err) {
+      return buf;
+    }
+  }
+
+  readBuffer(length) {
+    return this.buffer.slice(this.pos, (this.pos += length));
+  }
+
+  readUInt24BE() {
+    return (this.readUInt16BE() << 8) + this.readUInt8();
+  }
+
+  readUInt24LE() {
+    return this.readUInt16LE() + (this.readUInt8() << 16);
+  }
+
+  readInt24BE() {
+    return (this.readInt16BE() << 8) + this.readUInt8();
+  }
+
+  readInt24LE() {
+    return this.readUInt16LE() + (this.readInt8() << 16);
+  }
+}
+
+DecodeStream.TYPES = {
+  UInt8: 1,
+  UInt16: 2,
+  UInt24: 3,
+  UInt32: 4,
+  Int8: 1,
+  Int16: 2,
+  Int24: 3,
+  Int32: 4,
+  Float: 4,
+  Double: 8
+};
+
+for (let key of Object.getOwnPropertyNames(DataView.prototype)) {
+  if (key.slice(0, 3) === 'get') {
+    let type = key.slice(3).replace('Ui', 'UI');
+    if (type === 'Float32') {
+      type = 'Float';
+    } else if (type === 'Float64') {
+      type = 'Double';
+    }
+    let bytes = DecodeStream.TYPES[type];
+    DecodeStream.prototype['read' + type + (bytes === 1 ? '' : 'BE')] = function () {
+      const ret = this.view[key](this.pos, false);
+      this.pos += bytes;
+      return ret;
+    };
+
+    if (bytes !== 1) {
+      DecodeStream.prototype['read' + type + 'LE'] = function () {
+        const ret = this.view[key](this.pos, true);
+        this.pos += bytes;
+        return ret;
+      };
+    }
+  }
+}

package/node_modules/restructure/src/EncodeStream.js

@@ -0,0 +1,129 @@
+import {DecodeStream} from './DecodeStream.js';
+
+const textEncoder = new TextEncoder();
+const isBigEndian = new Uint8Array(new Uint16Array([0x1234]).buffer)[0] == 0x12;
+
+export class EncodeStream {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    this.pos = 0;
+  }
+
+  writeBuffer(buffer) {
+    this.buffer.set(buffer, this.pos);
+    this.pos += buffer.length;
+  }
+
+  writeString(string, encoding = 'ascii') {
+    let buf;
+    switch (encoding) {
+      case 'utf16le':
+      case 'utf16-le':
+      case 'ucs2': // node treats this the same as utf16.
+        buf = stringToUtf16(string, isBigEndian);
+        break;
+
+      case 'utf16be':
+      case 'utf16-be':
+        buf = stringToUtf16(string, !isBigEndian);
+        break;
+
+      case 'utf8':
+        buf = textEncoder.encode(string);
+        break;
+
+      case 'ascii':
+        buf = stringToAscii(string);
+        break;
+
+      default:
+        throw new Error(`Unsupported encoding: ${encoding}`);
+    }
+
+    this.writeBuffer(buf);
+  }
+
+  writeUInt24BE(val) {
+    this.buffer[this.pos++] = (val >>> 16) & 0xff;
+    this.buffer[this.pos++] = (val >>> 8) & 0xff;
+    this.buffer[this.pos++] = val & 0xff;
+  }
+
+  writeUInt24LE(val) {
+    this.buffer[this.pos++] = val & 0xff;
+    this.buffer[this.pos++] = (val >>> 8) & 0xff;
+    this.buffer[this.pos++] = (val >>> 16) & 0xff;
+  }
+
+  writeInt24BE(val) {
+    if (val >= 0) {
+      this.writeUInt24BE(val);
+    } else {
+      this.writeUInt24BE(val + 0xffffff + 1);
+    }
+  }
+
+  writeInt24LE(val) {
+    if (val >= 0) {
+      this.writeUInt24LE(val);
+    } else {
+      this.writeUInt24LE(val + 0xffffff + 1);
+    }
+  }
+
+  fill(val, length) {
+    if (length < this.buffer.length) {
+      this.buffer.fill(val, this.pos, this.pos + length);
+      this.pos += length;
+    } else {
+      const buf = new Uint8Array(length);
+      buf.fill(val);
+      this.writeBuffer(buf);
+    }
+  }
+}
+
+function stringToUtf16(string, swap) {
+  let buf = new Uint16Array(string.length);
+  for (let i = 0; i < string.length; i++) {
+    let code = string.charCodeAt(i);
+    if (swap) {
+      code = (code >> 8) | ((code & 0xff) << 8);
+    }
+    buf[i] = code;
+  }
+  return new Uint8Array(buf.buffer);
+}
+
+function stringToAscii(string) {
+  let buf = new Uint8Array(string.length);
+  for (let i = 0; i < string.length; i++) {
+    // Match node.js behavior - encoding allows 8-bit rather than 7-bit.
+    buf[i] = string.charCodeAt(i);
+  }
+  return buf;
+}
+
+for (let key of Object.getOwnPropertyNames(DataView.prototype)) {
+  if (key.slice(0, 3) === 'set') {
+    let type = key.slice(3).replace('Ui', 'UI');
+    if (type === 'Float32') {
+      type = 'Float';
+    } else if (type === 'Float64') {
+      type = 'Double';
+    }
+    let bytes = DecodeStream.TYPES[type];
+    EncodeStream.prototype['write' + type + (bytes === 1 ? '' : 'BE')] = function (value) {
+      this.view[key](this.pos, value, false);
+      this.pos += bytes;
+    };
+
+    if (bytes !== 1) {
+      EncodeStream.prototype['write' + type + 'LE'] = function (value) {
+        this.view[key](this.pos, value, true);
+        this.pos += bytes;
+      };
+    }
+  }
+}

package/node_modules/restructure/src/Enum.js

@@ -0,0 +1,27 @@
+import {Base} from './Base.js';
+
+export class Enum extends Base {
+  constructor(type, options = []) {
+    super();
+    this.type = type;
+    this.options = options;
+  }
+  
+  decode(stream) {
+    const index = this.type.decode(stream);
+    return this.options[index] || index;
+  }
+
+  size() {
+    return this.type.size();
+  }
+
+  encode(stream, val) {
+    const index = this.options.indexOf(val);
+    if (index === -1) {
+      throw new Error(`Unknown option in enum: ${val}`);
+    }
+
+    return this.type.encode(stream, index);
+  }
+}

package/node_modules/restructure/src/LazyArray.js

@@ -0,0 +1,74 @@
+import {Array as ArrayT} from './Array.js';
+import {Number as NumberT} from './Number.js';
+import * as utils from './utils.js';
+
+export class LazyArray extends ArrayT {
+  decode(stream, parent) {
+    const { pos } = stream;
+    const length = utils.resolveLength(this.length, stream, parent);
+
+    if (this.length instanceof NumberT) {
+      parent = {
+        parent,
+        _startOffset: pos,
+        _currentOffset: 0,
+        _length: length
+      };
+    }
+
+    const res = new LazyArrayValue(this.type, length, stream, parent);
+
+    stream.pos += length * this.type.size(null, parent);
+    return res;
+  }
+
+  size(val, ctx) {
+    if (val instanceof LazyArrayValue) {
+      val = val.toArray();
+    }
+
+    return super.size(val, ctx);
+  }
+
+  encode(stream, val, ctx) {
+    if (val instanceof LazyArrayValue) {
+      val = val.toArray();
+    }
+
+    return super.encode(stream, val, ctx);
+  }
+}
+
+class LazyArrayValue {
+  constructor(type, length, stream, ctx) {
+    this.type = type;
+    this.length = length;
+    this.stream = stream;
+    this.ctx = ctx;
+    this.base = this.stream.pos;
+    this.items = [];
+  }
+
+  get(index) {
+    if ((index < 0) || (index >= this.length)) {
+      return undefined;
+    }
+
+    if (this.items[index] == null) {
+      const { pos } = this.stream;
+      this.stream.pos = this.base + (this.type.size(null, this.ctx) * index);
+      this.items[index] = this.type.decode(this.stream, this.ctx);
+      this.stream.pos = pos;
+    }
+
+    return this.items[index];
+  }
+
+  toArray() {
+    const result = [];
+    for (let i = 0, end = this.length; i < end; i++) {
+      result.push(this.get(i));
+    }
+    return result;
+  }
+}

package/node_modules/restructure/src/Number.js

@@ -0,0 +1,77 @@
+import {DecodeStream} from './DecodeStream.js';
+import {Base} from './Base.js';
+
+class NumberT extends Base {
+  constructor(type, endian = 'BE') {
+    super();
+    this.type = type;
+    this.endian = endian;
+    this.fn = this.type;
+    if (this.type[this.type.length - 1] !== '8') {
+      this.fn += this.endian;
+    }
+  }
+
+  size() {
+    return DecodeStream.TYPES[this.type];
+  }
+
+  decode(stream) {
+    return stream[`read${this.fn}`]();
+  }
+
+  encode(stream, val) {
+    return stream[`write${this.fn}`](val);
+  }
+}
+
+export {NumberT as Number};
+
+export const uint8 = new NumberT('UInt8');
+export const uint16be = new NumberT('UInt16', 'BE');
+export const uint16 = uint16be;
+export const uint16le = new NumberT('UInt16', 'LE');
+export const uint24be = new NumberT('UInt24', 'BE');
+export const uint24 = uint24be;
+export const uint24le = new NumberT('UInt24', 'LE');
+export const uint32be = new NumberT('UInt32', 'BE');
+export const uint32 = uint32be;
+export const uint32le = new NumberT('UInt32', 'LE');
+export const int8 = new NumberT('Int8');
+export const int16be = new NumberT('Int16', 'BE');
+export const int16 = int16be;
+export const int16le = new NumberT('Int16', 'LE');
+export const int24be = new NumberT('Int24', 'BE');
+export const int24 = int24be;
+export const int24le = new NumberT('Int24', 'LE');
+export const int32be = new NumberT('Int32', 'BE');
+export const int32 = int32be;
+export const int32le = new NumberT('Int32', 'LE');
+export const floatbe = new NumberT('Float', 'BE');
+export const float = floatbe;
+export const floatle = new NumberT('Float', 'LE');
+export const doublebe = new NumberT('Double', 'BE');
+export const double = doublebe;
+export const doublele = new NumberT('Double', 'LE');
+
+export class Fixed extends NumberT {
+  constructor(size, endian, fracBits = size >> 1) {
+    super(`Int${size}`, endian);
+    this._point = 1 << fracBits;
+  }
+
+  decode(stream) {
+    return super.decode(stream) / this._point;
+  }
+
+  encode(stream, val) {
+    return super.encode(stream, (val * this._point) | 0);
+  }
+}
+
+export const fixed16be = new Fixed(16, 'BE');
+export const fixed16 = fixed16be;
+export const fixed16le = new Fixed(16, 'LE');
+export const fixed32be = new Fixed(32, 'BE');
+export const fixed32 = fixed32be;
+export const fixed32le = new Fixed(32, 'LE');