umwd-components 0.1.813 → 0.1.815

package/dist/esm/node_modules/queue/index.js

@@ -0,0 +1,211 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.js';
+import { __module as queue$1 } from '../../_virtual/index2.js';
+import { i as inherits_browserExports } from '../inherits/inherits_browser.js';
+import { e as eventsExports } from '../events/events.js';
+
+var inherits = inherits_browserExports;
+var EventEmitter = eventsExports.EventEmitter;
+
+queue$1.exports = Queue;
+queue$1.exports.default = Queue;
+
+function Queue (options) {
+  if (!(this instanceof Queue)) {
+    return new Queue(options)
+  }
+
+  EventEmitter.call(this);
+  options = options || {};
+  this.concurrency = options.concurrency || Infinity;
+  this.timeout = options.timeout || 0;
+  this.autostart = options.autostart || false;
+  this.results = options.results || null;
+  this.pending = 0;
+  this.session = 0;
+  this.running = false;
+  this.jobs = [];
+  this.timers = {};
+}
+inherits(Queue, EventEmitter);
+
+var arrayMethods = [
+  'pop',
+  'shift',
+  'indexOf',
+  'lastIndexOf'
+];
+
+arrayMethods.forEach(function (method) {
+  Queue.prototype[method] = function () {
+    return Array.prototype[method].apply(this.jobs, arguments)
+  };
+});
+
+Queue.prototype.slice = function (begin, end) {
+  this.jobs = this.jobs.slice(begin, end);
+  return this
+};
+
+Queue.prototype.reverse = function () {
+  this.jobs.reverse();
+  return this
+};
+
+var arrayAddMethods = [
+  'push',
+  'unshift',
+  'splice'
+];
+
+arrayAddMethods.forEach(function (method) {
+  Queue.prototype[method] = function () {
+    var methodResult = Array.prototype[method].apply(this.jobs, arguments);
+    if (this.autostart) {
+      this.start();
+    }
+    return methodResult
+  };
+});
+
+Object.defineProperty(Queue.prototype, 'length', {
+  get: function () {
+    return this.pending + this.jobs.length
+  }
+});
+
+Queue.prototype.start = function (cb) {
+  if (cb) {
+    callOnErrorOrEnd.call(this, cb);
+  }
+
+  this.running = true;
+
+  if (this.pending >= this.concurrency) {
+    return
+  }
+
+  if (this.jobs.length === 0) {
+    if (this.pending === 0) {
+      done.call(this);
+    }
+    return
+  }
+
+  var self = this;
+  var job = this.jobs.shift();
+  var once = true;
+  var session = this.session;
+  var timeoutId = null;
+  var didTimeout = false;
+  var resultIndex = null;
+  var timeout = job.hasOwnProperty('timeout') ? job.timeout : this.timeout;
+
+  function next (err, result) {
+    if (once && self.session === session) {
+      once = false;
+      self.pending--;
+      if (timeoutId !== null) {
+        delete self.timers[timeoutId];
+        clearTimeout(timeoutId);
+      }
+
+      if (err) {
+        self.emit('error', err, job);
+      } else if (didTimeout === false) {
+        if (resultIndex !== null) {
+          self.results[resultIndex] = Array.prototype.slice.call(arguments, 1);
+        }
+        self.emit('success', result, job);
+      }
+
+      if (self.session === session) {
+        if (self.pending === 0 && self.jobs.length === 0) {
+          done.call(self);
+        } else if (self.running) {
+          self.start();
+        }
+      }
+    }
+  }
+
+  if (timeout) {
+    timeoutId = setTimeout(function () {
+      didTimeout = true;
+      if (self.listeners('timeout').length > 0) {
+        self.emit('timeout', next, job);
+      } else {
+        next();
+      }
+    }, timeout);
+    this.timers[timeoutId] = timeoutId;
+  }
+
+  if (this.results) {
+    resultIndex = this.results.length;
+    this.results[resultIndex] = null;
+  }
+
+  this.pending++;
+  self.emit('start', job);
+  var promise = job(next);
+  if (promise && promise.then && typeof promise.then === 'function') {
+    promise.then(function (result) {
+      return next(null, result)
+    }).catch(function (err) {
+      return next(err || true)
+    });
+  }
+
+  if (this.running && this.jobs.length > 0) {
+    this.start();
+  }
+};
+
+Queue.prototype.stop = function () {
+  this.running = false;
+};
+
+Queue.prototype.end = function (err) {
+  clearTimers.call(this);
+  this.jobs.length = 0;
+  this.pending = 0;
+  done.call(this, err);
+};
+
+function clearTimers () {
+  for (var key in this.timers) {
+    var timeoutId = this.timers[key];
+    delete this.timers[key];
+    clearTimeout(timeoutId);
+  }
+}
+
+function callOnErrorOrEnd (cb) {
+  var self = this;
+  this.on('error', onerror);
+  this.on('end', onend);
+
+  function onerror (err) { self.end(err); }
+  function onend (err) {
+    self.removeListener('error', onerror);
+    self.removeListener('end', onend);
+    cb(err, this.results);
+  }
+}
+
+function done (err) {
+  this.session++;
+  this.running = false;
+  this.emit('end', err);
+}
+
+var queueExports = queue$1.exports;
+var queue = /*@__PURE__*/getDefaultExportFromCjs(queueExports);
+
+export { queue as default };

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

@@ -0,0 +1,112 @@
+/*
+ * 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 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 = 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) * 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/dist/esm/node_modules/restructure/src/Base.js

@@ -0,0 +1,25 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { DecodeStream } from './DecodeStream.js';
+import { EncodeStream } from './EncodeStream.js';
+
+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;
+  }
+}
+
+export { Base };

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

@@ -0,0 +1,47 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { Base } from './Base.js';
+
+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);
+  }
+}
+
+export { Bitfield };

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

@@ -0,0 +1,44 @@
+/*
+ * 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 BufferT extends Base {
+  constructor(length) {
+    super();
+    this.length = length;
+  }
+  
+  decode(stream, parent) {
+    const length = resolveLength(this.length, stream, parent);
+    return stream.readBuffer(length);
+  }
+
+  size(val, parent) {
+    if (!val) {
+      return 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, BufferT };

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

@@ -0,0 +1,93 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+// Node back-compat.
+const ENCODING_MAPPING = {
+  utf16le: 'utf-16le',
+  ucs2: 'utf-16le',
+  utf16be: 'utf-16be'
+};
+
+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;
+      };
+    }
+  }
+}
+
+export { DecodeStream };

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

@@ -0,0 +1,137 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { DecodeStream } from './DecodeStream.js';
+
+const textEncoder = new TextEncoder();
+const isBigEndian = new Uint8Array(new Uint16Array([0x1234]).buffer)[0] == 0x12;
+
+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;
+      };
+    }
+  }
+}
+
+export { EncodeStream };