module-develop-kit 1.1.0 → 1.2.1

package/dist/vendor/strtok3/lib/ReadStreamTokenizer.js

@@ -0,0 +1,91 @@
+import { AbstractTokenizer as o } from "./AbstractTokenizer.js";
+import { EndOfStreamError as a } from "./stream/Errors.js";
+const f = 256e3;
+class u extends o {
+  /**
+   * Constructor
+   * @param streamReader stream-reader to read from
+   * @param options Tokenizer options
+   */
+  constructor(t, n) {
+    super(n), this.streamReader = t, this.fileInfo = n?.fileInfo ?? {};
+  }
+  /**
+   * Read buffer from tokenizer
+   * @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
+   * @param options - Read behaviour options
+   * @returns Promise with number of bytes read
+   */
+  async readBuffer(t, n) {
+    const e = this.normalizeOptions(t, n), r = e.position - this.position;
+    if (r > 0)
+      return await this.ignore(r), this.readBuffer(t, n);
+    if (r < 0)
+      throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
+    if (e.length === 0)
+      return 0;
+    const s = await this.streamReader.read(t.subarray(0, e.length), e.mayBeLess);
+    if (this.position += s, (!n || !n.mayBeLess) && s < e.length)
+      throw new a();
+    return s;
+  }
+  /**
+   * Peek (read ahead) buffer from tokenizer
+   * @param uint8Array - Uint8Array (or Buffer) to write data to
+   * @param options - Read behaviour options
+   * @returns Promise with number of bytes peeked
+   */
+  async peekBuffer(t, n) {
+    const e = this.normalizeOptions(t, n);
+    let r = 0;
+    if (e.position) {
+      const s = e.position - this.position;
+      if (s > 0) {
+        const i = new Uint8Array(e.length + s);
+        return r = await this.peekBuffer(i, { mayBeLess: e.mayBeLess }), t.set(i.subarray(s)), r - s;
+      }
+      if (s < 0)
+        throw new Error("Cannot peek from a negative offset in a stream");
+    }
+    if (e.length > 0) {
+      try {
+        r = await this.streamReader.peek(t.subarray(0, e.length), e.mayBeLess);
+      } catch (s) {
+        if (n?.mayBeLess && s instanceof a)
+          return 0;
+        throw s;
+      }
+      if (!e.mayBeLess && r < e.length)
+        throw new a();
+    }
+    return r;
+  }
+  /**
+   * @param length Number of bytes to ignore. Must be ≥ 0.
+   */
+  async ignore(t) {
+    if (t < 0)
+      throw new RangeError("ignore length must be ≥ 0 bytes");
+    const n = Math.min(f, t), e = new Uint8Array(n);
+    let r = 0;
+    for (; r < t; ) {
+      const s = t - r, i = await this.readBuffer(e, { length: Math.min(n, s) });
+      if (i < 0)
+        return i;
+      r += i;
+    }
+    return r;
+  }
+  abort() {
+    return this.streamReader.abort();
+  }
+  async close() {
+    return this.streamReader.close();
+  }
+  supportsRandomAccess() {
+    return !1;
+  }
+}
+export {
+  u as ReadStreamTokenizer
+};

package/dist/vendor/strtok3/lib/core.js

@@ -0,0 +1,22 @@
+import { makeWebStreamReader as m } from "./stream/WebStreamReaderFactory.js";
+import { ReadStreamTokenizer as f } from "./ReadStreamTokenizer.js";
+import { BufferTokenizer as i } from "./BufferTokenizer.js";
+import { BlobTokenizer as a } from "./BlobTokenizer.js";
+function p(e, o) {
+  const n = m(e), r = o ?? {}, t = r.onClose;
+  return r.onClose = async () => {
+    if (await n.close(), t)
+      return t();
+  }, new f(n, r);
+}
+function b(e, o) {
+  return new i(e, o);
+}
+function w(e, o) {
+  return new a(e, o);
+}
+export {
+  w as fromBlob,
+  b as fromBuffer,
+  p as fromWebStream
+};

package/dist/vendor/strtok3/lib/stream/AbstractStreamReader.js

@@ -0,0 +1,51 @@
+import { EndOfStreamError as s, AbortError as i } from "./Errors.js";
+class d {
+  constructor() {
+    this.endOfStream = !1, this.interrupted = !1, this.peekQueue = [];
+  }
+  async peek(t, r = !1) {
+    const e = await this.read(t, r);
+    return this.peekQueue.push(t.subarray(0, e)), e;
+  }
+  async read(t, r = !1) {
+    if (t.length === 0)
+      return 0;
+    let e = this.readFromPeekBuffer(t);
+    if (this.endOfStream || (e += await this.readRemainderFromStream(t.subarray(e), r)), e === 0 && !r)
+      throw new s();
+    return e;
+  }
+  /**
+   * Read chunk from stream
+   * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+   * @returns Number of bytes read
+   */
+  readFromPeekBuffer(t) {
+    let r = t.length, e = 0;
+    for (; this.peekQueue.length > 0 && r > 0; ) {
+      const a = this.peekQueue.pop();
+      if (!a)
+        throw new Error("peekData should be defined");
+      const n = Math.min(a.length, r);
+      t.set(a.subarray(0, n), e), e += n, r -= n, n < a.length && this.peekQueue.push(a.subarray(n));
+    }
+    return e;
+  }
+  async readRemainderFromStream(t, r) {
+    let e = 0;
+    for (; e < t.length && !this.endOfStream; ) {
+      if (this.interrupted)
+        throw new i();
+      const a = await this.readFromStream(t.subarray(e), r);
+      if (a === 0)
+        break;
+      e += a;
+    }
+    if (!r && e < t.length)
+      throw new s();
+    return e;
+  }
+}
+export {
+  d as AbstractStreamReader
+};

package/dist/vendor/strtok3/lib/stream/Errors.js

@@ -0,0 +1,16 @@
+const t = "End-Of-Stream";
+class o extends Error {
+  constructor() {
+    super(t), this.name = "EndOfStreamError";
+  }
+}
+class s extends Error {
+  constructor(e = "The operation was aborted") {
+    super(e), this.name = "AbortError";
+  }
+}
+export {
+  s as AbortError,
+  o as EndOfStreamError,
+  t as defaultMessages
+};

package/dist/vendor/strtok3/lib/stream/WebStreamByobReader.js

@@ -0,0 +1,18 @@
+import { WebStreamReader as n } from "./WebStreamReader.js";
+class i extends n {
+  /**
+   * Read from stream
+   * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+   * @param mayBeLess - If true, may fill the buffer partially
+   * @protected Bytes read
+   */
+  async readFromStream(t, r) {
+    if (t.length === 0)
+      return 0;
+    const e = await this.reader.read(new Uint8Array(t.length), { min: r ? void 0 : t.length });
+    return e.done && (this.endOfStream = e.done), e.value ? (t.set(e.value), e.value.length) : 0;
+  }
+}
+export {
+  i as WebStreamByobReader
+};

package/dist/vendor/strtok3/lib/stream/WebStreamDefaultReader.js

@@ -0,0 +1,45 @@
+import { EndOfStreamError as s } from "./Errors.js";
+import { AbstractStreamReader as i } from "./AbstractStreamReader.js";
+class u extends i {
+  constructor(t) {
+    super(), this.reader = t, this.buffer = null;
+  }
+  /**
+   * Copy chunk to target, and store the remainder in this.buffer
+   */
+  writeChunk(t, r) {
+    const e = Math.min(r.length, t.length);
+    return t.set(r.subarray(0, e)), e < r.length ? this.buffer = r.subarray(e) : this.buffer = null, e;
+  }
+  /**
+   * Read from stream
+   * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+   * @param mayBeLess - If true, may fill the buffer partially
+   * @protected Bytes read
+   */
+  async readFromStream(t, r) {
+    if (t.length === 0)
+      return 0;
+    let e = 0;
+    for (this.buffer && (e += this.writeChunk(t, this.buffer)); e < t.length && !this.endOfStream; ) {
+      const a = await this.reader.read();
+      if (a.done) {
+        this.endOfStream = !0;
+        break;
+      }
+      a.value && (e += this.writeChunk(t.subarray(e), a.value));
+    }
+    if (!r && e === 0 && this.endOfStream)
+      throw new s();
+    return e;
+  }
+  abort() {
+    return this.interrupted = !0, this.reader.cancel();
+  }
+  async close() {
+    await this.abort(), this.reader.releaseLock();
+  }
+}
+export {
+  u as WebStreamDefaultReader
+};

package/dist/vendor/strtok3/lib/stream/WebStreamReader.js

@@ -0,0 +1,15 @@
+import { AbstractStreamReader as r } from "./AbstractStreamReader.js";
+class a extends r {
+  constructor(e) {
+    super(), this.reader = e;
+  }
+  async abort() {
+    return this.close();
+  }
+  async close() {
+    this.reader.releaseLock();
+  }
+}
+export {
+  a as WebStreamReader
+};

package/dist/vendor/strtok3/lib/stream/WebStreamReaderFactory.js

@@ -0,0 +1,15 @@
+import { WebStreamByobReader as a } from "./WebStreamByobReader.js";
+import { WebStreamDefaultReader as t } from "./WebStreamDefaultReader.js";
+function d(r) {
+  try {
+    const e = r.getReader({ mode: "byob" });
+    return e instanceof ReadableStreamDefaultReader ? new t(e) : new a(e);
+  } catch (e) {
+    if (e instanceof TypeError)
+      return new t(r.getReader());
+    throw e;
+  }
+}
+export {
+  d as makeWebStreamReader
+};

package/dist/vendor/token-types/lib/index.js

@@ -0,0 +1,81 @@
+import "../../../commonjs-virtual-dir/index4.js";
+import { textDecode as i } from "../../@borewit/text-codec/lib/index.js";
+function r(e) {
+  return new DataView(e.buffer, e.byteOffset);
+}
+const s = {
+  len: 1,
+  get(e, t) {
+    return r(e).getUint8(t);
+  },
+  put(e, t, n) {
+    return r(e).setUint8(t, n), t + 1;
+  }
+}, c = {
+  len: 2,
+  get(e, t) {
+    return r(e).getUint16(t, !0);
+  },
+  put(e, t, n) {
+    return r(e).setUint16(t, n, !0), t + 2;
+  }
+}, p = {
+  len: 2,
+  get(e, t) {
+    return r(e).getUint16(t);
+  },
+  put(e, t, n) {
+    return r(e).setUint16(t, n), t + 2;
+  }
+}, l = {
+  len: 4,
+  get(e, t) {
+    return r(e).getUint32(t, !0);
+  },
+  put(e, t, n) {
+    return r(e).setUint32(t, n, !0), t + 4;
+  }
+}, o = {
+  len: 4,
+  get(e, t) {
+    return r(e).getUint32(t);
+  },
+  put(e, t, n) {
+    return r(e).setUint32(t, n), t + 4;
+  }
+}, I = {
+  len: 4,
+  get(e, t) {
+    return r(e).getInt32(t);
+  },
+  put(e, t, n) {
+    return r(e).setInt32(t, n), t + 4;
+  }
+}, T = {
+  len: 8,
+  get(e, t) {
+    return r(e).getBigUint64(t, !0);
+  },
+  put(e, t, n) {
+    return r(e).setBigUint64(t, n, !0), t + 8;
+  }
+};
+class N {
+  constructor(t, n) {
+    this.len = t, this.encoding = n;
+  }
+  get(t, n = 0) {
+    const u = t.subarray(n, n + this.len);
+    return i(u, this.encoding);
+  }
+}
+export {
+  I as INT32_BE,
+  N as StringType,
+  p as UINT16_BE,
+  c as UINT16_LE,
+  o as UINT32_BE,
+  l as UINT32_LE,
+  T as UINT64_LE,
+  s as UINT8
+};

package/dist/vendor/uint8array-extras/index.js

@@ -0,0 +1,45 @@
+const f = Object.prototype.toString, c = "[object Uint8Array]";
+function u(t, r, e) {
+  return t ? t.constructor === r ? !0 : f.call(t) === e : !1;
+}
+function g(t) {
+  return u(t, Uint8Array, c);
+}
+function U(t) {
+  if (!g(t))
+    throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof t}\``);
+}
+function s(t, r) {
+  if (t.length === 0)
+    return new Uint8Array(0);
+  r ??= t.reduce((n, o) => n + o.length, 0);
+  const e = new Uint8Array(r);
+  let i = 0;
+  for (const n of t)
+    U(n), e.set(n, i), i += n.length;
+  return e;
+}
+new globalThis.TextDecoder("utf8");
+new globalThis.TextEncoder();
+Array.from({ length: 256 }, (t, r) => r.toString(16).padStart(2, "0"));
+function y(t) {
+  const { byteLength: r } = t;
+  if (r === 6)
+    return t.getUint16(0) * 2 ** 32 + t.getUint32(2);
+  if (r === 5)
+    return t.getUint8(0) * 2 ** 32 + t.getUint32(1);
+  if (r === 4)
+    return t.getUint32(0);
+  if (r === 3)
+    return t.getUint8(0) * 2 ** 16 + t.getUint16(1);
+  if (r === 2)
+    return t.getUint16(0);
+  if (r === 1)
+    return t.getUint8(0);
+}
+export {
+  U as assertUint8Array,
+  s as concatUint8Arrays,
+  y as getUintBE,
+  g as isUint8Array
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "module-develop-kit",
   "author": "Front-End team",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "type": "module",
   "description": "前端项目通用工具包",
   "module": "dist/main.js",
@@ -59,6 +59,7 @@
     "vue-tsc": "^3.0.7"
   },
   "dependencies": {
+    "file-type": "^22.0.1",
     "gm-crypt": "^0.0.2",
     "jssip": "^3.10.1",
     "sm-crypto": "^0.3.13"