module-develop-kit 1.1.0 → 1.2.1

package/dist/vendor/@borewit/text-codec/lib/index.js

@@ -0,0 +1,181 @@
+const g = {
+  128: "€",
+  130: "‚",
+  131: "ƒ",
+  132: "„",
+  133: "…",
+  134: "†",
+  135: "‡",
+  136: "ˆ",
+  137: "‰",
+  138: "Š",
+  139: "‹",
+  140: "Œ",
+  142: "Ž",
+  145: "‘",
+  146: "’",
+  147: "“",
+  148: "”",
+  149: "•",
+  150: "–",
+  151: "—",
+  152: "˜",
+  153: "™",
+  154: "š",
+  155: "›",
+  156: "œ",
+  158: "ž",
+  159: "Ÿ"
+};
+for (const [e, o] of Object.entries(g))
+  ;
+let a;
+function w() {
+  if (!(typeof globalThis.TextDecoder > "u"))
+    return a ?? (a = new globalThis.TextDecoder("utf-8"));
+}
+const d = 32 * 1024, r = 65533;
+function L(e, o = "utf-8") {
+  switch (o.toLowerCase()) {
+    case "utf-8":
+    case "utf8": {
+      const n = w();
+      return n ? n.decode(e) : T(e);
+    }
+    case "utf-16le":
+      return E(e);
+    case "us-ascii":
+    case "ascii":
+      return m(e);
+    case "latin1":
+    case "iso-8859-1":
+      return v(e);
+    case "windows-1252":
+      return D(e);
+    default:
+      throw new RangeError(`Encoding '${o}' not supported`);
+  }
+}
+function s(e, o) {
+  o.length !== 0 && (e.push(String.fromCharCode.apply(null, o)), o.length = 0);
+}
+function i(e, o, n) {
+  o.push(n), o.length >= d && s(e, o);
+}
+function j(e, o, n) {
+  if (n <= 65535) {
+    i(e, o, n);
+    return;
+  }
+  n -= 65536, i(e, o, 55296 + (n >> 10)), i(e, o, 56320 + (n & 1023));
+}
+function T(e) {
+  const o = [], n = [];
+  let t = 0;
+  for (e.length >= 3 && e[0] === 239 && e[1] === 187 && e[2] === 191 && (t = 3); t < e.length; ) {
+    const f = e[t];
+    if (f <= 127) {
+      i(o, n, f), t++;
+      continue;
+    }
+    if (f < 194 || f > 244) {
+      i(o, n, r), t++;
+      continue;
+    }
+    if (f <= 223) {
+      if (t + 1 >= e.length) {
+        i(o, n, r), t++;
+        continue;
+      }
+      const u = e[t + 1];
+      if ((u & 192) !== 128) {
+        i(o, n, r), t++;
+        continue;
+      }
+      const l = (f & 31) << 6 | u & 63;
+      i(o, n, l), t += 2;
+      continue;
+    }
+    if (f <= 239) {
+      if (t + 2 >= e.length) {
+        i(o, n, r), t++;
+        continue;
+      }
+      const u = e[t + 1], l = e[t + 2];
+      if (!((u & 192) === 128 && (l & 192) === 128 && !(f === 224 && u < 160) && // overlong
+      !(f === 237 && u >= 160))) {
+        i(o, n, r), t++;
+        continue;
+      }
+      const C = (f & 15) << 12 | (u & 63) << 6 | l & 63;
+      i(o, n, C), t += 3;
+      continue;
+    }
+    if (t + 3 >= e.length) {
+      i(o, n, r), t++;
+      continue;
+    }
+    const c = e[t + 1], x = e[t + 2], h = e[t + 3];
+    if (!((c & 192) === 128 && (x & 192) === 128 && (h & 192) === 128 && !(f === 240 && c < 144) && // overlong
+    !(f === 244 && c > 143))) {
+      i(o, n, r), t++;
+      continue;
+    }
+    const p = (f & 7) << 18 | (c & 63) << 12 | (x & 63) << 6 | h & 63;
+    j(o, n, p), t += 4;
+  }
+  return s(o, n), o.join("");
+}
+function E(e) {
+  const o = [], n = [], t = e.length;
+  let f = 0;
+  for (; f + 1 < t; ) {
+    const c = e[f] | e[f + 1] << 8;
+    if (f += 2, c >= 55296 && c <= 56319) {
+      if (f + 1 < t) {
+        const x = e[f] | e[f + 1] << 8;
+        x >= 56320 && x <= 57343 ? (i(o, n, c), i(o, n, x), f += 2) : i(o, n, r);
+      } else
+        i(o, n, r);
+      continue;
+    }
+    if (c >= 56320 && c <= 57343) {
+      i(o, n, r);
+      continue;
+    }
+    i(o, n, c);
+  }
+  return f < t && i(o, n, r), s(o, n), o.join("");
+}
+function m(e) {
+  const o = [];
+  for (let n = 0; n < e.length; n += d) {
+    const t = Math.min(e.length, n + d), f = new Array(t - n);
+    for (let c = n, x = 0; c < t; c++, x++)
+      f[x] = e[c] & 127;
+    o.push(String.fromCharCode.apply(null, f));
+  }
+  return o.join("");
+}
+function v(e) {
+  const o = [];
+  for (let n = 0; n < e.length; n += d) {
+    const t = Math.min(e.length, n + d), f = new Array(t - n);
+    for (let c = n, x = 0; c < t; c++, x++)
+      f[x] = e[c];
+    o.push(String.fromCharCode.apply(null, f));
+  }
+  return o.join("");
+}
+function D(e) {
+  const o = [];
+  let n = "";
+  for (let t = 0; t < e.length; t++) {
+    const f = e[t], c = f >= 128 && f <= 159 ? g[f] : void 0;
+    n += c ?? String.fromCharCode(f), n.length >= d && (o.push(n), n = "");
+  }
+  return n && o.push(n), o.join("");
+}
+export {
+  L as textDecode
+};

package/dist/vendor/@tokenizer/inflate/lib/GzipHandler.js

@@ -0,0 +1,21 @@
+class a {
+  constructor(e) {
+    this.tokenizer = e;
+  }
+  inflate() {
+    const e = this.tokenizer;
+    return new ReadableStream({
+      async pull(r) {
+        const t = new Uint8Array(1024), n = await e.readBuffer(t, { mayBeLess: !0 });
+        if (n === 0) {
+          r.close();
+          return;
+        }
+        r.enqueue(t.subarray(0, n));
+      }
+    }).pipeThrough(new DecompressionStream("gzip"));
+  }
+}
+export {
+  a as GzipHandler
+};

package/dist/vendor/@tokenizer/inflate/lib/ZipHandler.js

@@ -0,0 +1,156 @@
+import { UINT32_LE as h, StringType as k } from "../../../token-types/lib/index.js";
+import D from "../../../../commonjs-virtual-dir/browser.js";
+import { Signature as c, EndOfCentralDirectoryRecordToken as L, FileHeader as E, DataDescriptor as y, LocalFileHeaderToken as S } from "./ZipToken.js";
+function m(s) {
+  const t = new Uint8Array(h.len);
+  return h.put(t, 0, s), t;
+}
+const o = D("tokenizer:inflate"), p = 256 * 1024, C = m(c.DataDescriptor), l = m(c.EndOfCentralDirectory);
+class z {
+  constructor(t) {
+    this.tokenizer = t, this.syncBuffer = new Uint8Array(p);
+  }
+  async isZip() {
+    return await this.peekSignature() === c.LocalFileHeader;
+  }
+  peekSignature() {
+    return this.tokenizer.peekToken(h);
+  }
+  async findEndOfCentralDirectoryLocator() {
+    const t = this.tokenizer, n = Math.min(16 * 1024, t.fileInfo.size), r = this.syncBuffer.subarray(0, n);
+    await this.tokenizer.readBuffer(r, { position: t.fileInfo.size - n });
+    for (let e = r.length - 4; e >= 0; e--)
+      if (r[e] === l[0] && r[e + 1] === l[1] && r[e + 2] === l[2] && r[e + 3] === l[3])
+        return t.fileInfo.size - n + e;
+    return -1;
+  }
+  async readCentralDirectory() {
+    if (!this.tokenizer.supportsRandomAccess()) {
+      o("Cannot reading central-directory without random-read support");
+      return;
+    }
+    o("Reading central-directory...");
+    const t = this.tokenizer.position, n = await this.findEndOfCentralDirectoryLocator();
+    if (n > 0) {
+      o("Central-directory 32-bit signature found");
+      const r = await this.tokenizer.readToken(L, n), e = [];
+      this.tokenizer.setPosition(r.offsetOfStartOfCd);
+      for (let i = 0; i < r.nrOfEntriesOfSize; ++i) {
+        const a = await this.tokenizer.readToken(E);
+        if (a.signature !== c.CentralFileHeader)
+          throw new Error("Expected Central-File-Header signature");
+        a.filename = await this.tokenizer.readToken(new k(a.filenameLength, "utf-8")), await this.tokenizer.ignore(a.extraFieldLength), await this.tokenizer.ignore(a.fileCommentLength), e.push(a), o(`Add central-directory file-entry: n=${i + 1}/${e.length}: filename=${e[i].filename}`);
+      }
+      return this.tokenizer.setPosition(t), e;
+    }
+    this.tokenizer.setPosition(t);
+  }
+  async unzip(t) {
+    const n = await this.readCentralDirectory();
+    if (n)
+      return this.iterateOverCentralDirectory(n, t);
+    let r = !1;
+    do {
+      const e = await this.readLocalFileHeader();
+      if (!e)
+        break;
+      const i = t(e);
+      r = !!i.stop;
+      let a;
+      if (await this.tokenizer.ignore(e.extraFieldLength), e.dataDescriptor && e.compressedSize === 0) {
+        const u = [];
+        let d = p;
+        o("Compressed-file-size unknown, scanning for next data-descriptor-signature....");
+        let f = -1;
+        for (; f < 0 && d === p; ) {
+          d = await this.tokenizer.peekBuffer(this.syncBuffer, { mayBeLess: !0 }), f = F(this.syncBuffer.subarray(0, d), C);
+          const w = f >= 0 ? f : d;
+          if (i.handler) {
+            const g = new Uint8Array(w);
+            await this.tokenizer.readBuffer(g), u.push(g);
+          } else
+            await this.tokenizer.ignore(w);
+        }
+        o(`Found data-descriptor-signature at pos=${this.tokenizer.position}`), i.handler && await this.inflate(e, T(u), i.handler);
+      } else
+        i.handler ? (o(`Reading compressed-file-data: ${e.compressedSize} bytes`), a = new Uint8Array(e.compressedSize), await this.tokenizer.readBuffer(a), await this.inflate(e, a, i.handler)) : (o(`Ignoring compressed-file-data: ${e.compressedSize} bytes`), await this.tokenizer.ignore(e.compressedSize));
+      if (o(`Reading data-descriptor at pos=${this.tokenizer.position}`), e.dataDescriptor && (await this.tokenizer.readToken(y)).signature !== 134695760)
+        throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - y.len}`);
+    } while (!r);
+  }
+  async iterateOverCentralDirectory(t, n) {
+    for (const r of t) {
+      const e = n(r);
+      if (e.handler) {
+        this.tokenizer.setPosition(r.relativeOffsetOfLocalHeader);
+        const i = await this.readLocalFileHeader();
+        if (i) {
+          await this.tokenizer.ignore(i.extraFieldLength);
+          const a = new Uint8Array(r.compressedSize);
+          await this.tokenizer.readBuffer(a), await this.inflate(i, a, e.handler);
+        }
+      }
+      if (e.stop)
+        break;
+    }
+  }
+  async inflate(t, n, r) {
+    if (t.compressedMethod === 0)
+      return r(n);
+    if (t.compressedMethod !== 8)
+      throw new Error(`Unsupported ZIP compression method: ${t.compressedMethod}`);
+    o(`Decompress filename=${t.filename}, compressed-size=${n.length}`);
+    const e = await z.decompressDeflateRaw(n);
+    return r(e);
+  }
+  static async decompressDeflateRaw(t) {
+    const n = new ReadableStream({
+      start(i) {
+        i.enqueue(t), i.close();
+      }
+    }), r = new DecompressionStream("deflate-raw"), e = n.pipeThrough(r);
+    try {
+      const a = await new Response(e).arrayBuffer();
+      return new Uint8Array(a);
+    } catch (i) {
+      const a = i instanceof Error ? `Failed to deflate ZIP entry: ${i.message}` : "Unknown decompression error in ZIP entry";
+      throw new TypeError(a);
+    }
+  }
+  async readLocalFileHeader() {
+    const t = await this.tokenizer.peekToken(h);
+    if (t === c.LocalFileHeader) {
+      const n = await this.tokenizer.readToken(S);
+      return n.filename = await this.tokenizer.readToken(new k(n.filenameLength, "utf-8")), n;
+    }
+    if (t === c.CentralFileHeader)
+      return !1;
+    throw t === 3759263696 ? new Error("Encrypted ZIP") : new Error("Unexpected signature");
+  }
+}
+function F(s, t) {
+  const n = s.length, r = t.length;
+  if (r > n)
+    return -1;
+  for (let e = 0; e <= n - r; e++) {
+    let i = !0;
+    for (let a = 0; a < r; a++)
+      if (s[e + a] !== t[a]) {
+        i = !1;
+        break;
+      }
+    if (i)
+      return e;
+  }
+  return -1;
+}
+function T(s) {
+  const t = s.reduce((e, i) => e + i.length, 0), n = new Uint8Array(t);
+  let r = 0;
+  for (const e of s)
+    n.set(e, r), r += e.length;
+  return n;
+}
+export {
+  z as ZipHandler
+};

package/dist/vendor/@tokenizer/inflate/lib/ZipToken.js

@@ -0,0 +1,71 @@
+import { UINT16_LE as t, UINT32_LE as n } from "../../../token-types/lib/index.js";
+const s = {
+  LocalFileHeader: 67324752,
+  DataDescriptor: 134695760,
+  CentralFileHeader: 33639248,
+  EndOfCentralDirectory: 101010256
+}, o = {
+  get(e) {
+    return {
+      signature: n.get(e, 0),
+      compressedSize: n.get(e, 8),
+      uncompressedSize: n.get(e, 12)
+    };
+  },
+  len: 16
+}, l = {
+  get(e) {
+    const i = t.get(e, 6);
+    return {
+      signature: n.get(e, 0),
+      minVersion: t.get(e, 4),
+      dataDescriptor: !!(i & 8),
+      compressedMethod: t.get(e, 8),
+      compressedSize: n.get(e, 18),
+      uncompressedSize: n.get(e, 22),
+      filenameLength: t.get(e, 26),
+      extraFieldLength: t.get(e, 28),
+      filename: null
+    };
+  },
+  len: 30
+}, c = {
+  get(e) {
+    return {
+      signature: n.get(e, 0),
+      nrOfThisDisk: t.get(e, 4),
+      nrOfThisDiskWithTheStart: t.get(e, 6),
+      nrOfEntriesOnThisDisk: t.get(e, 8),
+      nrOfEntriesOfSize: t.get(e, 10),
+      sizeOfCd: n.get(e, 12),
+      offsetOfStartOfCd: n.get(e, 16),
+      zipFileCommentLength: t.get(e, 20)
+    };
+  },
+  len: 22
+}, d = {
+  get(e) {
+    const i = t.get(e, 8);
+    return {
+      signature: n.get(e, 0),
+      minVersion: t.get(e, 6),
+      dataDescriptor: !!(i & 8),
+      compressedMethod: t.get(e, 10),
+      compressedSize: n.get(e, 20),
+      uncompressedSize: n.get(e, 24),
+      filenameLength: t.get(e, 28),
+      extraFieldLength: t.get(e, 30),
+      fileCommentLength: t.get(e, 32),
+      relativeOffsetOfLocalHeader: n.get(e, 42),
+      filename: null
+    };
+  },
+  len: 46
+};
+export {
+  o as DataDescriptor,
+  c as EndOfCentralDirectoryRecordToken,
+  d as FileHeader,
+  l as LocalFileHeaderToken,
+  s as Signature
+};

package/dist/vendor/base64-js/index.js

@@ -1,4 +1,4 @@
-import { __exports as F } from "../../commonjs-virtual-dir/index6.js";
+import { __exports as F } from "../../commonjs-virtual-dir/index8.js";
 var A;
 function _() {
   if (A) return F;

package/dist/vendor/debug/src/browser.js

@@ -1,4 +1,4 @@
-import { __module as C } from "../../../commonjs-virtual-dir/browser.js";
+import { __module as C } from "../../../commonjs-virtual-dir/browser2.js";
 import { __require as g } from "./common.js";
 var F;
 function p() {

package/dist/vendor/file-type/source/detectors/asf.js

@@ -0,0 +1,74 @@
+import { UINT64_LE as p } from "../../../token-types/lib/index.js";
+import { EndOfStreamError as h } from "../../../strtok3/lib/stream/Errors.js";
+import { safeReadBuffer as o, safeIgnore as d, hasUnknownFileSize as u, hasExceededUnknownSizeScanBudget as F, maximumUntrustedSkipSizeInBytes as S, checkBytes as n, ParserHardLimitError as w } from "../parser.js";
+const y = 512, c = 1024 * 1024;
+async function b(e) {
+  let a = !1;
+  try {
+    async function i() {
+      const x = new Uint8Array(16);
+      return await o(e, x, void 0, {
+        maximumLength: x.length,
+        reason: "ASF header GUID"
+      }), {
+        id: x,
+        size: Number(await e.readToken(p))
+      };
+    }
+    await d(e, 30, {
+      maximumLength: 30,
+      reason: "ASF header prelude"
+    });
+    const s = u(e), l = e.position;
+    let f = 0;
+    for (; e.position + 24 < e.fileInfo.size && (f++, !(f > y || F(e, l, S))); ) {
+      const x = e.position, m = await i();
+      let t = m.size - 24;
+      if (!Number.isFinite(t) || t < 0) {
+        a = !0;
+        break;
+      }
+      if (n(m.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
+        const r = new Uint8Array(16);
+        if (t -= await o(e, r, void 0, {
+          maximumLength: r.length,
+          reason: "ASF stream type GUID"
+        }), n(r, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43]))
+          return {
+            ext: "asf",
+            mime: "audio/x-ms-asf"
+          };
+        if (n(r, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43]))
+          return {
+            ext: "asf",
+            mime: "video/x-ms-asf"
+          };
+        break;
+      }
+      if (s && t > c) {
+        a = !0;
+        break;
+      }
+      if (await d(e, t, {
+        maximumLength: s ? c : e.fileInfo.size,
+        reason: "ASF header payload"
+      }), e.position <= x) {
+        a = !0;
+        break;
+      }
+    }
+  } catch (i) {
+    if (i instanceof h || i instanceof w)
+      u(e) && (a = !0);
+    else
+      throw i;
+  }
+  if (!a)
+    return {
+      ext: "asf",
+      mime: "application/vnd.ms-asf"
+    };
+}
+export {
+  b as detectAsf
+};

package/dist/vendor/file-type/source/detectors/ebml.js

@@ -0,0 +1,61 @@
+import { StringType as p, UINT8 as g } from "../../../token-types/lib/index.js";
+import { getUintBE as l } from "../../../uint8array-extras/index.js";
+import { hasExceededUnknownSizeScanBudget as h, getSafeBound as y, hasUnknownFileSize as r, safeIgnore as b, safeReadBuffer as E, maximumUntrustedSkipSizeInBytes as x } from "../parser.js";
+const c = 64, u = 1024 * 1024, S = 256;
+async function V(t) {
+  async function o() {
+    const i = await t.peekNumber(g);
+    let n = 128, a = 0;
+    for (; (i & n) === 0 && n !== 0; )
+      ++a, n >>= 1;
+    const e = new Uint8Array(a + 1);
+    return await E(t, e, void 0, {
+      maximumLength: e.length,
+      reason: "EBML field"
+    }), e;
+  }
+  async function s() {
+    const i = await o(), n = await o();
+    n[0] ^= 128 >> n.length - 1;
+    const a = Math.min(6, n.length), e = new DataView(i.buffer), m = new DataView(n.buffer, n.length - a, a);
+    return {
+      id: l(e),
+      len: l(m)
+    };
+  }
+  async function d(i) {
+    let n = 0;
+    for (; i > 0; ) {
+      if (n++, n > S || h(t, f, x))
+        return;
+      const a = t.position, e = await s();
+      if (e.id === 17026) {
+        if (e.len > c)
+          return;
+        const m = y(e.len, c, "EBML DocType");
+        return (await t.readToken(new p(m))).replaceAll(new RegExp("\\0.*$", "gv"), "");
+      }
+      if (r(t) && (!Number.isFinite(e.len) || e.len < 0 || e.len > u) || (await b(t, e.len, {
+        maximumLength: r(t) ? u : t.fileInfo.size,
+        reason: "EBML payload"
+      }), --i, t.position <= a))
+        return;
+    }
+  }
+  const w = await s(), f = t.position;
+  switch (await d(w.len)) {
+    case "webm":
+      return {
+        ext: "webm",
+        mime: "video/webm"
+      };
+    case "matroska":
+      return {
+        ext: "mkv",
+        mime: "video/matroska"
+      };
+  }
+}
+export {
+  V as detectEbml
+};

package/dist/vendor/file-type/source/detectors/png.js

@@ -0,0 +1,64 @@
+import { StringType as f, INT32_BE as p } from "../../../token-types/lib/index.js";
+import { EndOfStreamError as h } from "../../../strtok3/lib/stream/Errors.js";
+import { hasUnknownFileSize as l, hasExceededUnknownSizeScanBudget as d, safeIgnore as y, ParserHardLimitError as w } from "../parser.js";
+const S = 512, I = 16 * 1024 * 1024, s = 1024 * 1024;
+function P(n) {
+  return (n.codePointAt(0) & 32) !== 0;
+}
+async function B(n) {
+  const t = {
+    ext: "png",
+    mime: "image/png"
+  }, u = {
+    ext: "apng",
+    mime: "image/apng"
+  };
+  await n.ignore(8);
+  async function c() {
+    return {
+      length: await n.readToken(p),
+      type: await n.readToken(new f(4, "latin1"))
+    };
+  }
+  const a = l(n), g = n.position;
+  let o = 0, i = !1;
+  do {
+    if (o++, o > S || d(n, g, I))
+      break;
+    const m = n.position, e = await c();
+    if (e.length < 0)
+      return;
+    if (e.type === "IHDR") {
+      if (e.length !== 13)
+        return;
+      i = !0;
+    }
+    switch (e.type) {
+      case "IDAT":
+        return t;
+      case "acTL":
+        return u;
+      default:
+        if (!i && e.type !== "CgBI")
+          return;
+        if (a && e.length > s)
+          return i && P(e.type) ? t : void 0;
+        try {
+          await y(n, e.length + 4, {
+            maximumLength: a ? s + 4 : n.fileInfo.size,
+            reason: "PNG chunk payload"
+          });
+        } catch (r) {
+          if (!a && (r instanceof w || r instanceof h))
+            return t;
+          throw r;
+        }
+    }
+    if (n.position <= m)
+      break;
+  } while (n.position + 8 < n.fileInfo.size);
+  return t;
+}
+export {
+  B as detectPng
+};