umwd-components 0.1.813 → 0.1.815

package/dist/esm/node_modules/restructure/src/LazyArray.js

@@ -0,0 +1,82 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { Array as ArrayT } from './Array.js';
+import { Number as NumberT } from './Number.js';
+import { resolveLength } from './utils.js';
+
+class LazyArray extends ArrayT {
+  decode(stream, parent) {
+    const { pos } = stream;
+    const length = 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;
+  }
+}
+
+export { LazyArray };

package/dist/esm/node_modules/restructure/src/Number.js

@@ -0,0 +1,80 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+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);
+  }
+}
+
+const uint8 = new NumberT('UInt8');
+const uint16be = new NumberT('UInt16', 'BE');
+const uint16 = uint16be;
+const uint16le = new NumberT('UInt16', 'LE');
+const uint24be = new NumberT('UInt24', 'BE');
+const uint24 = uint24be;
+new NumberT('UInt24', 'LE');
+const uint32be = new NumberT('UInt32', 'BE');
+const uint32 = uint32be;
+const uint32le = new NumberT('UInt32', 'LE');
+const int8 = new NumberT('Int8');
+const int16be = new NumberT('Int16', 'BE');
+const int16 = int16be;
+new NumberT('Int16', 'LE');
+new NumberT('Int24', 'BE');
+new NumberT('Int24', 'LE');
+const int32be = new NumberT('Int32', 'BE');
+const int32 = int32be;
+new NumberT('Int32', 'LE');
+new NumberT('Float', 'BE');
+new NumberT('Float', 'LE');
+new NumberT('Double', 'BE');
+new NumberT('Double', 'LE');
+
+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);
+  }
+}
+
+const fixed16be = new Fixed(16, 'BE');
+const fixed16 = fixed16be;
+new Fixed(16, 'LE');
+const fixed32be = new Fixed(32, 'BE');
+const fixed32 = fixed32be;
+new Fixed(32, 'LE');
+
+export { Fixed, NumberT as Number, fixed16, fixed16be, fixed32, fixed32be, int16, int16be, int32, int32be, int8, uint16, uint16be, uint16le, uint24, uint24be, uint32, uint32be, uint32le, uint8 };

package/dist/esm/node_modules/restructure/src/Optional.js

@@ -0,0 +1,52 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { Base } from './Base.js';
+
+class Optional extends Base {
+  constructor(type, condition = true) {
+    super();
+    this.type = type;
+    this.condition = condition;
+  }
+
+  decode(stream, parent) {
+    let { condition } = this;
+    if (typeof condition === 'function') {
+      condition = condition.call(parent, parent);
+    }
+
+    if (condition) {
+      return this.type.decode(stream, parent);
+    }
+  }
+
+  size(val, parent) {
+    let { condition } = this;
+    if (typeof condition === 'function') {
+      condition = condition.call(parent, parent);
+    }
+
+    if (condition) {
+      return this.type.size(val, parent);
+    } else {
+      return 0;
+    }
+  }
+
+  encode(stream, val, parent) {
+    let { condition } = this;
+    if (typeof condition === 'function') {
+      condition = condition.call(parent, parent);
+    }
+
+    if (condition) {
+      return this.type.encode(stream, val, parent);
+    }
+  }
+}
+
+export { Optional };

package/dist/esm/node_modules/restructure/src/Pointer.js

@@ -0,0 +1,175 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { PropertyDescriptor } from './utils.js';
+import { Base } from './Base.js';
+
+class Pointer extends Base {
+  constructor(offsetType, type, options = {}) {
+    super();
+    this.offsetType = offsetType;
+    this.type = type;
+    this.options = options;
+    if (this.type === 'void') { this.type = null; }
+    if (this.options.type == null) { this.options.type = 'local'; }
+    if (this.options.allowNull == null) { this.options.allowNull = true; }
+    if (this.options.nullValue == null) { this.options.nullValue = 0; }
+    if (this.options.lazy == null) { this.options.lazy = false; }
+    if (this.options.relativeTo) {
+      if (typeof this.options.relativeTo !== 'function') {
+        throw new Error('relativeTo option must be a function');
+      }
+      this.relativeToGetter = options.relativeTo;
+    }
+  }
+
+  decode(stream, ctx) {
+    const offset = this.offsetType.decode(stream, ctx);
+
+    // handle NULL pointers
+    if ((offset === this.options.nullValue) && this.options.allowNull) {
+      return null;
+    }
+
+    let relative;
+    switch (this.options.type) {
+      case 'local':     relative = ctx._startOffset; break;
+      case 'immediate': relative = stream.pos - this.offsetType.size(); break;
+      case 'parent':    relative = ctx.parent._startOffset; break;
+      default:
+        var c = ctx;
+        while (c.parent) {
+          c = c.parent;
+        }
+
+        relative = c._startOffset || 0;
+    }
+
+    if (this.options.relativeTo) {
+      relative += this.relativeToGetter(ctx);
+    }
+
+    const ptr = offset + relative;
+
+    if (this.type != null) {
+      let val = null;
+      const decodeValue = () => {
+        if (val != null) { return val; }
+
+        const { pos } = stream;
+        stream.pos = ptr;
+        val = this.type.decode(stream, ctx);
+        stream.pos = pos;
+        return val;
+      };
+
+      // If this is a lazy pointer, define a getter to decode only when needed.
+      // This obviously only works when the pointer is contained by a Struct.
+      if (this.options.lazy) {
+        return new PropertyDescriptor({
+          get: decodeValue});
+      }
+
+      return decodeValue();
+    } else {
+      return ptr;
+    }
+  }
+
+  size(val, ctx) {
+    const parent = ctx;
+    switch (this.options.type) {
+      case 'local': case 'immediate':
+        break;
+      case 'parent':
+        ctx = ctx.parent;
+        break;
+      default: // global
+        while (ctx.parent) {
+          ctx = ctx.parent;
+        }
+    }
+
+    let { type } = this;
+    if (type == null) {
+      if (!(val instanceof VoidPointer)) {
+        throw new Error("Must be a VoidPointer");
+      }
+
+      ({ type } = val);
+      val = val.value;
+    }
+
+    if (val && ctx) {
+      // Must be written as two separate lines rather than += in case `type.size` mutates ctx.pointerSize.
+      let size = type.size(val, parent);
+      ctx.pointerSize += size;
+    }
+
+    return this.offsetType.size();
+  }
+
+  encode(stream, val, ctx) {
+    let relative;
+    const parent = ctx;
+    if ((val == null)) {
+      this.offsetType.encode(stream, this.options.nullValue);
+      return;
+    }
+
+    switch (this.options.type) {
+      case 'local':
+        relative = ctx.startOffset;
+        break;
+      case 'immediate':
+        relative = stream.pos + this.offsetType.size(val, parent);
+        break;
+      case 'parent':
+        ctx = ctx.parent;
+        relative = ctx.startOffset;
+        break;
+      default: // global
+        relative = 0;
+        while (ctx.parent) {
+          ctx = ctx.parent;
+        }
+    }
+
+    if (this.options.relativeTo) {
+      relative += this.relativeToGetter(parent.val);
+    }
+
+    this.offsetType.encode(stream, ctx.pointerOffset - relative);
+
+    let { type } = this;
+    if (type == null) {
+      if (!(val instanceof VoidPointer)) {
+        throw new Error("Must be a VoidPointer");
+      }
+
+      ({ type } = val);
+      val = val.value;
+    }
+
+    ctx.pointers.push({
+      type,
+      val,
+      parent
+    });
+
+    return ctx.pointerOffset += type.size(val, parent);
+  }
+}
+
+// A pointer whose type is determined at decode time
+class VoidPointer {
+  constructor(type, value) {
+    this.type = type;
+    this.value = value;
+  }
+}
+
+export { Pointer, VoidPointer };

package/dist/esm/node_modules/restructure/src/Reserved.js

@@ -0,0 +1,31 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { Base } from './Base.js';
+import { resolveLength } from './utils.js';
+
+class Reserved extends Base {
+  constructor(type, count = 1) {
+    super();
+    this.type = type;
+    this.count = count;
+  }
+  decode(stream, parent) {
+    stream.pos += this.size(null, parent);
+    return undefined;
+  }
+
+  size(data, parent) {
+    const count = resolveLength(this.count, null, parent);
+    return this.type.size() * count;
+  }
+
+  encode(stream, val, parent) {
+    return stream.fill(0, this.size(val, parent));
+  }
+}
+
+export { Reserved };

package/dist/esm/node_modules/restructure/src/String.js

@@ -0,0 +1,161 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { Base } from './Base.js';
+import { Number as NumberT } from './Number.js';
+import { resolveLength } from './utils.js';
+
+class StringT extends Base {
+  constructor(length, encoding = 'ascii') {
+    super();
+    this.length = length;
+    this.encoding = encoding;
+  }
+
+  decode(stream, parent) {
+    let length, pos;
+
+    let { encoding } = this;
+    if (typeof encoding === 'function') {
+      encoding = encoding.call(parent, parent) || 'ascii';
+    }
+    let width = encodingWidth(encoding);
+
+    if (this.length != null) {
+      length = resolveLength(this.length, stream, parent);
+    } else {
+      let buffer;
+      ({buffer, length, pos} = stream);
+
+      while ((pos < length - width + 1) &&
+        (buffer[pos] !== 0x00 ||
+        (width === 2 && buffer[pos+1] !== 0x00)
+        )) {
+        pos += width;
+      }
+
+      length = pos - stream.pos;
+    }
+
+
+    const string = stream.readString(length, encoding);
+
+    if ((this.length == null) && (stream.pos < stream.length)) {
+      stream.pos+=width;
+    }
+
+    return string;
+  }
+
+  size(val, parent) {
+    // Use the defined value if no value was given
+    if (val === undefined || val === null) {
+      return resolveLength(this.length, null, parent);
+    }
+
+    let { encoding } = this;
+    if (typeof encoding === 'function') {
+      encoding = encoding.call(parent != null ? parent.val : undefined, parent != null ? parent.val : undefined) || 'ascii';
+    }
+
+    if (encoding === 'utf16be') {
+      encoding = 'utf16le';
+    }
+
+    let size = byteLength(val, encoding);
+    if (this.length instanceof NumberT) {
+      size += this.length.size();
+    }
+
+    if ((this.length == null)) {
+      size += encodingWidth(encoding);
+    }
+
+    return size;
+  }
+
+  encode(stream, val, parent) {
+    let { encoding } = this;
+    if (typeof encoding === 'function') {
+      encoding = encoding.call(parent != null ? parent.val : undefined, parent != null ? parent.val : undefined) || 'ascii';
+    }
+
+    if (this.length instanceof NumberT) {
+      this.length.encode(stream, byteLength(val, encoding));
+    }
+
+    stream.writeString(val, encoding);
+
+    if ((this.length == null)) {
+      return encodingWidth(encoding) == 2 ?
+        stream.writeUInt16LE(0x0000) :
+        stream.writeUInt8(0x00);
+    }
+  }
+}
+
+function encodingWidth(encoding) {
+  switch(encoding) {
+    case 'ascii':
+    case 'utf8': // utf8 is a byte-based encoding for zero-term string
+      return 1;
+    case 'utf16le':
+    case 'utf16-le':
+    case 'utf-16be':
+    case 'utf-16le':
+    case 'utf16be':
+    case 'utf16-be':
+    case 'ucs2':
+      return 2;
+    default:
+      //TODO: assume all other encodings are 1-byters
+      //throw new Error('Unknown encoding ' + encoding);
+      return 1;
+  }
+}
+
+function byteLength(string, encoding) {
+  switch (encoding) {
+    case 'ascii':
+      return string.length;
+    case 'utf8':
+      let len = 0;
+      for (let i = 0; i < string.length; i++) {
+        let c = string.charCodeAt(i);
+
+        if (c >= 0xd800 && c <= 0xdbff && i < string.length - 1) {
+          let c2 = string.charCodeAt(++i);
+          if ((c2 & 0xfc00) === 0xdc00) {
+            c = ((c & 0x3ff) << 10) + (c2 & 0x3ff) + 0x10000;
+          } else {
+            // unmatched surrogate.
+            i--;
+          }
+        }
+
+        if ((c & 0xffffff80) === 0) {
+          len++;
+        } else if ((c & 0xfffff800) === 0) {
+          len += 2;
+        } else if ((c & 0xffff0000) === 0) {
+          len += 3;
+        } else if ((c & 0xffe00000) === 0) {
+          len += 4;
+        }
+      }
+      return len;
+    case 'utf16le':
+    case 'utf16-le':
+    case 'utf16be':
+    case 'utf16-be':
+    case 'ucs2':
+      return string.length * 2;
+    default:
+      throw new Error('Unknown encoding ' + encoding);
+  }
+}
+
+export { StringT as String };

package/dist/esm/node_modules/restructure/src/Struct.js

@@ -0,0 +1,121 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { Base } from './Base.js';
+import { PropertyDescriptor } from './utils.js';
+
+class Struct extends Base {
+  constructor(fields = {}) {
+    super();
+    this.fields = fields;
+  }
+
+  decode(stream, parent, length = 0) {
+    const res = this._setup(stream, parent, length);
+    this._parseFields(stream, res, this.fields);
+
+    if (this.process != null) {
+      this.process.call(res, stream);
+    }
+    return res;
+  }
+
+  _setup(stream, parent, length) {
+    const res = {};
+
+    // define hidden properties
+    Object.defineProperties(res, {
+      parent:         { value: parent },
+      _startOffset:   { value: stream.pos },
+      _currentOffset: { value: 0, writable: true },
+      _length:        { value: length }
+    });
+
+    return res;
+  }
+
+  _parseFields(stream, res, fields) {
+    for (let key in fields) {
+      var val;
+      const type = fields[key];
+      if (typeof type === 'function') {
+        val = type.call(res, res);
+      } else {
+        val = type.decode(stream, res);
+      }
+
+      if (val !== undefined) {
+        if (val instanceof PropertyDescriptor) {
+          Object.defineProperty(res, key, val);
+        } else {
+          res[key] = val;
+        }
+      }
+
+      res._currentOffset = stream.pos - res._startOffset;
+    }
+
+  }
+
+  size(val, parent, includePointers = true) {
+    if (val == null) { val = {}; }
+    const ctx = {
+      parent,
+      val,
+      pointerSize: 0
+    };
+
+    if (this.preEncode != null) {
+      this.preEncode.call(val);
+    }
+
+    let size = 0;
+    for (let key in this.fields) {
+      const type = this.fields[key];
+      if (type.size != null) {
+        size += type.size(val[key], ctx);
+      }
+    }
+
+    if (includePointers) {
+      size += ctx.pointerSize;
+    }
+
+    return size;
+  }
+
+  encode(stream, val, parent) {
+    let type;
+    if (this.preEncode != null) {
+      this.preEncode.call(val, stream);
+    }
+
+    const ctx = {
+      pointers: [],
+      startOffset: stream.pos,
+      parent,
+      val,
+      pointerSize: 0
+    };
+
+    ctx.pointerOffset = stream.pos + this.size(val, ctx, false);
+
+    for (let key in this.fields) {
+      type = this.fields[key];
+      if (type.encode != null) {
+        type.encode(stream, val[key], ctx);
+      }
+    }
+
+    let i = 0;
+    while (i < ctx.pointers.length) {
+      const ptr = ctx.pointers[i++];
+      ptr.type.encode(stream, ptr.val, ptr.parent);
+    }
+  }
+}
+
+export { Struct };