module-develop-kit 1.4.2 → 1.5.0

package/dist/vendor/file-type/source/index.js

@@ -1,9 +1,9 @@
-import { UINT32_BE as T, UINT16_BE as p, StringType as S, UINT16_LE as g, UINT32_LE as C } from "../../token-types/lib/index.js";
-import { fromWebStream as z, fromBuffer as I, fromBlob as M } from "../../strtok3/lib/core.js";
+import { UINT32_BE as T, UINT16_BE as p, StringType as S, UINT16_LE as g, UINT32_LE as z } from "../../token-types/lib/index.js";
+import { fromWebStream as I, fromBuffer as M, fromBlob as O } from "../../strtok3/lib/core.js";
 import "../../@tokenizer/inflate/lib/ZipHandler.js";
-import { GzipHandler as O } from "../../@tokenizer/inflate/lib/GzipHandler.js";
-import { concatUint8Arrays as P } from "../../uint8array-extras/index.js";
-import { stringToBytes as j, uint32SyncSafeToken as R, tarHeaderChecksumMatches as L } from "./tokens.js";
+import { GzipHandler as P } from "../../@tokenizer/inflate/lib/GzipHandler.js";
+import { concatUint8Arrays as j } from "../../uint8array-extras/index.js";
+import { stringToBytes as A, uint32SyncSafeToken as L, tarHeaderChecksumMatches as R } from "./tokens.js";
 import { mimeTypes as N, extensions as U } from "./supported.js";
 import { ParserHardLimitError as q, hasUnknownFileSize as l, checkBytes as h, safeIgnore as F, maximumUntrustedSkipSizeInBytes as b } from "./parser.js";
 import { detectZip as G } from "./detectors/zip.js";
@@ -11,71 +11,75 @@ import { detectEbml as _ } from "./detectors/ebml.js";
 import { detectPng as H } from "./detectors/png.js";
 import { detectAsf as V } from "./detectors/asf.js";
 import { EndOfStreamError as d } from "../../strtok3/lib/stream/Errors.js";
-const k = 4100, W = k - 2, $ = b, K = 1, A = 100, w = b, X = 512, v = 256, Z = 1024 * 1024, B = b;
-function J(n) {
-  return Number.isFinite(n) ? Math.max(1, Math.trunc(n)) : k;
+const k = 4100, W = k - 4, $ = b, K = 1, B = 100, w = b, X = 512, v = 256, Z = 1024 * 1024, D = b;
+function J(s) {
+  return Number.isFinite(s) ? Math.max(1, Math.trunc(s)) : k;
 }
-function Q(n) {
-  return Number.isFinite(n) ? Math.max(0, Math.min(W, Math.trunc(n))) : 0;
+function Q(s) {
+  return Number.isFinite(s) ? Math.max(0, Math.min(W, Math.trunc(s))) : 0;
 }
-function Y(n) {
-  return Number.isFinite(n) ? Math.max(0, n) : Number.MAX_SAFE_INTEGER;
+function Y(s) {
+  return Number.isFinite(s) ? Math.max(0, s) : Number.MAX_SAFE_INTEGER;
 }
-function D(n) {
-  return import(n);
+function E(s) {
+  return import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    s
+  );
 }
-function ee(n) {
-  return n.pipeThrough(new TransformStream());
+function ee(s) {
+  return s.pipeThrough(new TransformStream());
 }
-function E(n, e) {
-  return e === void 0 ? n.read() : (e.throwIfAborted(), Promise.race([
-    n.read(),
-    new Promise((t, i) => {
+function C(s, e) {
+  return e === void 0 ? s.read() : (e.throwIfAborted(), Promise.race([
+    s.read(),
+    new Promise((i, r) => {
       e.addEventListener("abort", () => {
-        i(e.reason), n.cancel(e.reason).catch(() => {
+        r(e.reason), s.cancel(e.reason).catch(() => {
         });
       }, { once: !0 });
     })
   ]));
 }
-function te(n, e) {
-  const t = n.getReader();
-  let i = 0, r = !1, s = !1;
+function te(s, e) {
+  const i = s.getReader();
+  let r = 0, t = !1, n = !1;
   const c = async (x) => {
-    r || s || (s = !0, await t.cancel(x));
+    t || n || (n = !0, await i.cancel(x));
   };
   return new ReadableStream({
     async pull(x) {
-      if (i >= e) {
+      if (r >= e) {
         x.close(), await c();
         return;
       }
-      const { done: f, value: a } = await t.read();
+      const { done: f, value: a } = await i.read();
       if (f || !a) {
-        r = !0, x.close();
+        t = !0, x.close();
         return;
       }
-      const u = e - i;
+      const u = e - r;
       if (a.length > u) {
-        x.enqueue(a.subarray(0, u)), i += u, x.close(), await c();
+        x.enqueue(a.subarray(0, u)), r += u, x.close(), await c();
         return;
       }
-      x.enqueue(a), i += a.length;
+      x.enqueue(a), r += a.length;
     },
     async cancel(x) {
       await c(x);
     }
   });
 }
-async function le(n, e) {
-  return new y(e).fromStream(n);
+async function le(s, e) {
+  return new y(e).fromStream(s);
 }
 class y {
   constructor(e) {
-    const t = Q(e?.mpegOffsetTolerance);
+    const i = Q(e?.mpegOffsetTolerance);
     this.options = {
       ...e,
-      mpegOffsetTolerance: t
+      mpegOffsetTolerance: i
     }, this.detectors = [
       ...this.options.customDetectors ?? [],
       { id: "core", detect: this.detectConfident },
@@ -90,23 +94,23 @@ class y {
     };
   }
   createTokenizerFromWebStream(e) {
-    return z(ee(e), this.getTokenizerOptions());
+    return I(ee(e), this.getTokenizerOptions());
   }
-  async parseTokenizer(e, t = 0) {
-    this.detectionReentryCount = t;
-    const i = e.position;
-    for (const r of this.detectors) {
-      let s;
+  async parseTokenizer(e, i = 0) {
+    this.detectionReentryCount = i;
+    const r = e.position;
+    for (const t of this.detectors) {
+      let n;
       try {
-        s = await r.detect(e);
+        n = await t.detect(e);
       } catch (c) {
         if (c instanceof d || c instanceof q)
           return;
         throw c;
       }
-      if (s)
-        return s;
-      if (i !== e.position)
+      if (n)
+        return n;
+      if (r !== e.position)
         return;
     }
   }
@@ -120,68 +124,68 @@ class y {
   async fromBuffer(e) {
     if (!(e instanceof Uint8Array || e instanceof ArrayBuffer))
       throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof e}\``);
-    const t = e instanceof Uint8Array ? e : new Uint8Array(e);
-    if (t?.length > 1)
-      return this.fromTokenizer(I(t, this.getTokenizerOptions()));
+    const i = e instanceof Uint8Array ? e : new Uint8Array(e);
+    if (i?.length > 1)
+      return this.fromTokenizer(M(i, this.getTokenizerOptions()));
   }
   async fromBlob(e) {
     this.options.signal?.throwIfAborted();
-    const t = M(e, this.getTokenizerOptions());
-    return this.fromTokenizer(t);
+    const i = O(e, this.getTokenizerOptions());
+    return this.fromTokenizer(i);
   }
   async fromStream(e) {
     this.options.signal?.throwIfAborted();
-    const t = this.createTokenizerFromWebStream(e);
-    return this.fromTokenizer(t);
+    const i = this.createTokenizerFromWebStream(e);
+    return this.fromTokenizer(i);
   }
   async fromFile(e) {
     this.options.signal?.throwIfAborted();
-    const [{ default: t }, { FileTokenizer: i }] = await Promise.all([
-      D("node:fs/promises"),
-      D("strtok3")
-    ]), r = await t.open(e, t.constants.O_RDONLY | t.constants.O_NONBLOCK), s = await r.stat();
-    if (!s.isFile()) {
-      await r.close();
+    const [{ default: i }, { FileTokenizer: r }] = await Promise.all([
+      E("node:fs/promises"),
+      E("strtok3")
+    ]), t = await i.open(e, i.constants.O_RDONLY | i.constants.O_NONBLOCK), n = await t.stat();
+    if (!n.isFile()) {
+      await t.close();
       return;
     }
-    const c = new i(r, {
+    const c = new r(t, {
       ...this.getTokenizerOptions(),
-      fileInfo: { path: e, size: s.size }
+      fileInfo: { path: e, size: n.size }
     });
     return this.fromTokenizer(c);
   }
-  async toDetectionStream(e, t) {
+  async toDetectionStream(e, i) {
     this.options.signal?.throwIfAborted();
-    const i = J(t?.sampleSize ?? k);
-    let r, s = !1;
+    const r = J(i?.sampleSize ?? k);
+    let t, n = !1;
     const c = e.getReader(), x = [];
     let f = 0;
     try {
-      for (; f < i; ) {
-        const { value: m, done: o } = await E(c, this.options.signal);
+      for (; f < r; ) {
+        const { value: m, done: o } = await C(c, this.options.signal);
         if (o || !m) {
-          s = !0;
+          n = !0;
           break;
         }
         x.push(m), f += m.length;
       }
-      if (!s && f === i) {
-        const { value: m, done: o } = await E(c, this.options.signal);
-        o || !m ? s = !0 : (x.push(m), f += m.length);
+      if (!n && f === r) {
+        const { value: m, done: o } = await C(c, this.options.signal);
+        o || !m ? n = !0 : (x.push(m), f += m.length);
       }
     } finally {
       c.releaseLock();
     }
     if (f > 0) {
-      const m = x.length === 1 ? x[0] : P(x);
+      const m = x.length === 1 ? x[0] : j(x);
       try {
-        r = await this.fromBuffer(m.subarray(0, i));
+        t = await this.fromBuffer(m.subarray(0, r));
       } catch (o) {
         if (!(o instanceof d))
           throw o;
-        r = void 0;
+        t = void 0;
       }
-      !s && r?.ext === "pages" && (r = {
+      !n && t?.ext === "pages" && (t = {
         ext: "zip",
         mime: "application/zip"
       });
@@ -195,7 +199,7 @@ class y {
         o.enqueue(m);
       }
     }), u = e.pipeThrough(a);
-    return u.fileType = r, u;
+    return u.fileType = t, u;
   }
   async detectGzip(e) {
     if (this.gzipProbeDepth >= K)
@@ -203,25 +207,25 @@ class y {
         ext: "gz",
         mime: "application/gzip"
       };
-    const t = new O(e), i = te(t.inflate(), $), r = l(e);
-    let s, c, x, f;
-    if (r) {
+    const i = new P(e), r = te(i.inflate(), $), t = l(e);
+    let n, c, x, f;
+    if (t) {
       const a = new AbortController();
-      s = setTimeout(() => {
-        a.abort(new DOMException(`Operation timed out after ${A} ms`, "TimeoutError"));
-      }, A), c = this.options.signal === void 0 ? a.signal : AbortSignal.any([this.options.signal, a.signal]), x = new y({
+      n = setTimeout(() => {
+        a.abort(new DOMException(`Operation timed out after ${B} ms`, "TimeoutError"));
+      }, B), c = this.options.signal === void 0 ? a.signal : AbortSignal.any([this.options.signal, a.signal]), x = new y({
         ...this.options,
         signal: c
       }), x.gzipProbeDepth = this.gzipProbeDepth + 1;
     } else
       this.gzipProbeDepth++;
     try {
-      f = await (x ?? this).fromStream(i);
+      f = await (x ?? this).fromStream(r);
     } catch (a) {
       if (a?.name === "AbortError" && c?.reason?.name !== "TimeoutError")
         throw a;
     } finally {
-      clearTimeout(s), r || this.gzipProbeDepth--;
+      clearTimeout(n), t || this.gzipProbeDepth--;
     }
     return f?.ext === "tar" ? {
       ext: "tar.gz",
@@ -231,11 +235,11 @@ class y {
       mime: "application/gzip"
     };
   }
-  check(e, t) {
-    return h(this.buffer, e, t);
+  check(e, i) {
+    return h(this.buffer, e, i);
   }
-  checkString(e, t) {
-    return this.check(j(e, t?.encoding), t);
+  checkString(e, i) {
+    return this.check(A(e, i?.encoding), i);
   }
   // Detections with a high degree of certainty in identifying the correct file type
   detectConfident = async (e) => {
@@ -308,23 +312,23 @@ class y {
         maximumLength: 6,
         reason: "ID3 header prefix"
       });
-      const t = await e.readToken(R), i = l(e);
-      if (!Number.isFinite(t) || t < 0 || i && (t > w || e.position + t > w))
+      const t = await e.readToken(L), n = l(e);
+      if (!Number.isFinite(t) || t < 0 || n && (t > w || e.position + t > w))
         return;
       if (e.position + t > e.fileInfo.size)
-        return i ? void 0 : {
+        return n ? void 0 : {
           ext: "mp3",
           mime: "audio/mpeg"
         };
       try {
         await F(e, t, {
-          maximumLength: i ? w : e.fileInfo.size,
+          maximumLength: n ? w : e.fileInfo.size,
           reason: "ID3 payload"
         });
-      } catch (r) {
-        if (r instanceof d)
+      } catch (c) {
+        if (c instanceof d)
           return;
-        throw r;
+        throw c;
       }
       return this.detectionReentryCount >= v ? void 0 : (this.detectionReentryCount++, this.parseTokenizer(e, this.detectionReentryCount));
     }
@@ -608,13 +612,13 @@ class y {
         mime: "application/vnd.ms-htmlhelp"
       };
     if (this.check([202, 254, 186, 190])) {
-      const t = T.get(this.buffer, 4), i = p.get(this.buffer, 6);
+      const t = T.get(this.buffer, 4), n = p.get(this.buffer, 6);
       if (t > 0 && t <= 30)
         return {
           ext: "macho",
           mime: "application/x-mach-binary"
         };
-      if (i > 30)
+      if (n > 30)
         return {
           ext: "class",
           mime: "application/java-vm"
@@ -893,8 +897,8 @@ class y {
       const t = new DataView(this.buffer.buffer).getUint32(12, !0);
       if (t > 12 && this.buffer.length >= t + 16)
         try {
-          const i = new TextDecoder().decode(this.buffer.subarray(16, t + 16));
-          if (JSON.parse(i).files)
+          const n = new TextDecoder().decode(this.buffer.subarray(16, t + 16));
+          if (JSON.parse(n).files)
             return {
               ext: "asar",
               mime: "application/x-asar"
@@ -963,7 +967,7 @@ class y {
         ext: "jmp",
         mime: "application/x-jmp-data"
       };
-    if (await e.peekBuffer(this.buffer, { length: Math.min(512, e.fileInfo.size), mayBeLess: !0 }), this.checkString("ustar", { offset: 257 }) && (this.checkString("\0", { offset: 262 }) || this.checkString(" ", { offset: 262 })) || this.check([0, 0, 0, 0, 0, 0], { offset: 257 }) && L(this.buffer))
+    if (await e.peekBuffer(this.buffer, { length: Math.min(512, e.fileInfo.size), mayBeLess: !0 }), this.checkString("ustar", { offset: 257 }) && (this.checkString("\0", { offset: 262 }) || this.checkString(" ", { offset: 262 })) || this.check([0, 0, 0, 0, 0, 0], { offset: 257 }) && R(this.buffer))
       return {
         ext: "tar",
         mime: "application/x-tar"
@@ -987,12 +991,25 @@ class y {
         ext: "pgp",
         mime: "application/pgp-encrypted"
       };
+    const i = 32769, r = 5;
+    if (e.supportsRandomAccess() && e.fileInfo.size >= i + r) {
+      const t = new Uint8Array(r);
+      if (await e.peekBuffer(t, {
+        position: i,
+        length: r,
+        mayBeLess: !0
+      }), h(t, A("CD001")))
+        return {
+          ext: "iso",
+          mime: "application/x-iso9660-image"
+        };
+    }
   };
   // Detections with limited supporting data, resulting in a higher likelihood of false positives
   detectImprecise = async (e) => {
     this.buffer = new Uint8Array(k);
-    const t = Y(e.fileInfo.size);
-    if (await e.peekBuffer(this.buffer, { length: Math.min(8, t), mayBeLess: !0 }), this.check([0, 0, 1, 186]) || this.check([0, 0, 1, 179]))
+    const i = Y(e.fileInfo.size);
+    if (await e.peekBuffer(this.buffer, { length: Math.min(8, i), mayBeLess: !0 }), this.check([0, 0, 1, 186]) || this.check([0, 0, 1, 179]))
       return {
         ext: "mpg",
         mime: "video/mpeg"
@@ -1012,16 +1029,16 @@ class y {
         ext: "cur",
         mime: "image/x-icon"
       };
-    if (await e.peekBuffer(this.buffer, { length: Math.min(2 + this.options.mpegOffsetTolerance, t), mayBeLess: !0 }), this.buffer.length >= 2 + this.options.mpegOffsetTolerance)
-      for (let i = 0; i <= this.options.mpegOffsetTolerance; ++i) {
-        const r = this.scanMpeg(i);
-        if (r)
-          return r;
+    if (await e.peekBuffer(this.buffer, { length: Math.min(4 + this.options.mpegOffsetTolerance, i), mayBeLess: !0 }), this.buffer.length >= 4 + this.options.mpegOffsetTolerance)
+      for (let r = 0; r <= this.options.mpegOffsetTolerance; ++r) {
+        const t = this.scanMpeg(r);
+        if (t)
+          return t;
       }
   };
   async readTiffTag(e) {
-    const t = await this.tokenizer.readToken(e ? p : g);
-    switch (await this.tokenizer.ignore(10), t) {
+    const i = await this.tokenizer.readToken(e ? p : g);
+    switch (await this.tokenizer.ignore(10), i) {
       case 50341:
         return {
           ext: "arw",
@@ -1035,27 +1052,27 @@ class y {
     }
   }
   async readTiffIFD(e) {
-    const t = await this.tokenizer.readToken(e ? p : g);
-    if (!(t > X) && !(l(this.tokenizer) && 2 + t * 12 > B))
-      for (let i = 0; i < t; ++i) {
-        const r = await this.readTiffTag(e);
-        if (r)
-          return r;
+    const i = await this.tokenizer.readToken(e ? p : g);
+    if (!(i > X) && !(l(this.tokenizer) && 2 + i * 12 > D))
+      for (let r = 0; r < i; ++r) {
+        const t = await this.readTiffTag(e);
+        if (t)
+          return t;
       }
   }
   async readTiffHeader(e) {
-    const t = {
+    const i = {
       ext: "tif",
       mime: "image/tiff"
-    }, i = (e ? p : g).get(this.buffer, 2), r = (e ? T : C).get(this.buffer, 4);
-    if (i === 42) {
-      if (r >= 6) {
+    }, r = (e ? p : g).get(this.buffer, 2), t = (e ? T : z).get(this.buffer, 4);
+    if (r === 42) {
+      if (t >= 6) {
         if (this.checkString("CR", { offset: 8 }))
           return {
             ext: "cr2",
             mime: "image/x-canon-cr2"
           };
-        if (r >= 8) {
+        if (t >= 8) {
           const x = (e ? p : g).get(this.buffer, 8), f = (e ? p : g).get(this.buffer, 10);
           if (x === 28 && f === 254 || x === 31 && f === 11)
             return {
@@ -1064,12 +1081,12 @@ class y {
             };
         }
       }
-      if (l(this.tokenizer) && r > Z)
-        return t;
-      const s = l(this.tokenizer) ? B : this.tokenizer.fileInfo.size;
+      if (l(this.tokenizer) && t > Z)
+        return i;
+      const n = l(this.tokenizer) ? D : this.tokenizer.fileInfo.size;
       try {
-        await F(this.tokenizer, r, {
-          maximumLength: s,
+        await F(this.tokenizer, t, {
+          maximumLength: n,
           reason: "TIFF IFD offset"
         });
       } catch (x) {
@@ -1085,10 +1102,10 @@ class y {
           return;
         throw x;
       }
-      return c ?? t;
+      return c ?? i;
     }
-    if (i === 43)
-      return t;
+    if (r === 43)
+      return i;
   }
   /**
   	Scan check MPEG 1 or 2 Layer 3 header, or 'layer 0' for ADTS (MPEG sync-word 0xFFE).
@@ -1099,13 +1116,12 @@ class y {
   scanMpeg(e) {
     if (this.check([255, 224], { offset: e, mask: [255, 224] })) {
       if (this.check([16], { offset: e + 1, mask: [22] }))
-        return this.check([8], { offset: e + 1, mask: [8] }) ? {
-          ext: "aac",
-          mime: "audio/aac"
-        } : {
+        return {
           ext: "aac",
           mime: "audio/aac"
         };
+      if (this.check([255, 254], { offset: e }) || this.check([8], { offset: e + 1, mask: [24] }) || this.check([240], { offset: e + 2, mask: [240] }) || this.check([12], { offset: e + 2, mask: [12] }))
+        return;
       if (this.check([2], { offset: e + 1, mask: [6] }))
         return {
           ext: "mp3",

package/dist/vendor/file-type/source/supported.js

@@ -181,7 +181,8 @@ const a = [
   "dat",
   "key",
   "numbers",
-  "pages"
+  "pages",
+  "iso"
 ], i = [
   "image/jpeg",
   "image/png",
@@ -364,7 +365,8 @@ const a = [
   "application/x-jmp-data",
   "application/vnd.apple.keynote",
   "application/vnd.apple.numbers",
-  "application/vnd.apple.pages"
+  "application/vnd.apple.pages",
+  "application/x-iso9660-image"
 ];
 export {
   a as extensions,

package/dist/vendor/gm-crypt/index.js

@@ -0,0 +1,10 @@
+import { __require as t } from "./src/sm4.js";
+var r, e;
+function m() {
+  return e || (e = 1, r = {
+    sm4: t()
+  }), r;
+}
+export {
+  m as __require
+};

package/dist/vendor/gm-crypt/src/crypt.js

@@ -0,0 +1,60 @@
+import { __require as a } from "../../base64-js/index.js";
+import n from "util";
+var t, d;
+function y() {
+  if (d) return t;
+  d = 1;
+  const o = a();
+  class c {
+    /**
+     * Converts a JS string to an UTF-8 uint8array.
+     *
+     * @static
+     * @param {String} str 16-bit unicode string.
+     * @return {Uint8Array} UTF-8 Uint8Array.
+     * @memberof Crypt
+     */
+    static stringToArrayBufferInUtf8(e) {
+      const r = typeof window > "u" ? n.TextEncoder : window.TextEncoder;
+      return new r().encode(e);
+    }
+    /**
+     * Converts an UTF-8 uint8array to a JS string.
+     *
+     * @static
+     * @param {Uint8Array} strBuffer UTF-8 Uint8Array.
+     * @return {String} 16-bit unicode string.
+     * @memberof Crypt
+     */
+    static utf8ArrayBufferToString(e) {
+      const r = typeof window > "u" ? n.TextDecoder : window.TextDecoder;
+      return new r("utf-8").decode(e);
+    }
+    /**
+     * crypt a utf8 byteArray to base64 string
+     *
+     * @static
+     * @param {Uint8Array} strBuffer UTF-8 Uint8Array.
+     * @returns {String} base64 str
+     * @memberof Crypt
+     */
+    static arrayBufferToBase64(e) {
+      return o.fromByteArray(e);
+    }
+    /**
+     * crypt base64 stringa to utf8 byteArray
+     *
+     * @static
+     * @param {String} base64 str
+     * @returns {Uint8Array} strBuffer UTF-8 Uint8Array.
+     * @memberof Crypt
+     */
+    static base64ToArrayBuffer(e) {
+      return o.toByteArray(e);
+    }
+  }
+  return t = c, t;
+}
+export {
+  y as __require
+};