metamaker-for-three 0.1.8-0

package/src/lib/core/utils/ResetMaterial.ts

@@ -0,0 +1,264 @@
+/* eslint-disable*/
+import * as THREE from "three";
+import SSSLUT from "@/assets/SSSLUT.png";
+import { b64toBlob, splitb64 } from ".";
+let splitb64Result = splitb64(SSSLUT);
+let SSSLUTBlob = b64toBlob(splitb64Result.b64Data, splitb64Result.contentType);
+let SSSLUTBlobURL = URL.createObjectURL(SSSLUTBlob);
+function replaceAll(string, find, replace) {
+  return string.split(find).join(replace);
+}
+const meshphong_frag_head = THREE.ShaderChunk["meshphysical_frag"].slice(
+  0,
+  THREE.ShaderChunk["meshphysical_frag"].indexOf("void main() {")
+);
+const meshphong_frag_body = THREE.ShaderChunk["meshphysical_frag"].slice(
+  THREE.ShaderChunk["meshphysical_frag"].indexOf("void main() {")
+);
+const loader = new THREE.TextureLoader();
+const _SSSLUTTexture = loader.load(SSSLUTBlobURL);
+const SubsurfaceScatteringShader = {
+  uniforms: THREE.UniformsUtils.merge([
+    THREE.ShaderLib["standard"].uniforms,
+    {
+      _SSSLUT: {
+        value: _SSSLUTTexture,
+      },
+      _CurveFactor: {
+        value: 0.8,
+      },
+      _SSSFactor: {
+        value: 0.3,
+      },
+    },
+  ]),
+  vertexShader: ["#define USE_UV", THREE.ShaderChunk["meshphong_vert"]].join("\n"),
+  fragmentShader: [
+    meshphong_frag_head,
+    "uniform sampler2D _SSSLUT;",
+    "uniform float _CurveFactor;",
+    "uniform float _SSSFactor;",
+    "void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry,  const in PhysicalMaterial material,inout ReflectedLight reflectedLight) {",
+    "float dotNL = saturate( dot( geometry.normal, directLight.direction ) );",
+    "vec3 irradiance = dotNL * directLight.color;",
+    "reflectedLight.directDiffuse -= irradiance * BRDF_Lambert( material.diffuseColor )*_SSSFactor;",
+    "	float NoL = dot(geometry.normal, directLight.direction);",
+    "	vec4 diffuse =texture2D(_SSSLUT,vec2(NoL * 0.5 + 0.5,_CurveFactor));",
+    "	reflectedLight.directDiffuse += diffuse.xyz * directLight.color* BRDF_Lambert( material.diffuseColor )*_SSSFactor;",
+    "}",
+    meshphong_frag_body.replace(
+      "#include <lights_fragment_begin>",
+      replaceAll(
+        THREE.ShaderChunk["lights_fragment_begin"],
+        "RE_Direct( directLight, geometry, material, reflectedLight );",
+        [
+          "RE_Direct( directLight, geometry, material, reflectedLight );",
+          "RE_Direct_Scattering(directLight, vUv, geometry, material,reflectedLight);",
+        ].join("\n")
+      )
+    ),
+  ].join("\n"),
+};
+
+
+
+
+
+export function resetPolygonOffset(model,camera)
+{
+  //return;
+  model.traverse((n) => {
+    if (n.material != null ){
+      if(n.material.name.indexOf("Hair") >= 0) {
+      } else if (n.material.name.indexOf("DiffNormalPacked") >= 0||n.material.name.indexOf("Custom/Diff") >= 0) {
+      }else if (n.material.name.indexOf("head_sss") >= 0||n.material.name.indexOf("body_sss") >= 0 ){
+      } else if (n.material.name.indexOf("eye") >= 0||n.material.name.indexOf("Eye") >= 0 ||n.material.name.indexOf("yachi") >= 0||n.material.name.indexOf("Eye") >= 0 ){
+      }
+      else
+      {
+        console.log("XXXXXXXXXXXXXXXXXXXXXXX"+n.name+"  "+n.material.name);
+
+        var m=n.material.clone();
+        m.polygonOffset=true;
+
+        m.polygonOffsetFactor = -1.0;
+        var p = model.position.clone().sub(camera.position);
+        p.y = 0;
+        console.log(p);
+        m.polygonOffsetUnits = -3000.0 / p.length();
+        n.material = m;
+      }
+    }
+  });
+}
+export function resetMaterial(model) {
+  const hairs: any[] = [];
+  const s=1.04;
+  model.traverse((n) => {
+    if (n.material != null) {
+      if (n.material.name.indexOf("Hair") >= 0) {
+        hairs.push(n);
+        n.scale.x=n.scale.x*s;
+        n.scale.z=n.scale.z*s;
+      } else if (
+        n.material.name.indexOf("DiffNormalPacked") >= 0 ||
+        n.material.name.indexOf("Custom/Diff") >= 0
+      ) {
+        n.scale.x=n.scale.x*s;
+        n.scale.z=n.scale.z*s;
+        const m = new THREE.MeshBasicMaterial({
+          side: THREE.DoubleSide,
+        });
+        m.map = n.material.map;
+        m.name = n.material.name + "_resetMaterial_hat";
+        n.material = m;
+      } else {
+        // n.material.roughness=0.8;
+      }
+     resetSSSMaterial(n);
+    }
+  });
+
+  hairs.forEach((n) => {
+    const materialFirstPass = new THREE.MeshBasicMaterial({
+      alphaTest: 0.99,
+      transparent: false,
+      side: THREE.DoubleSide,
+    });
+    const materialBackSide = new THREE.MeshBasicMaterial({
+      blending: THREE.NormalBlending,
+      blendEquation: THREE.AddEquation,
+      blendSrc: THREE.SrcAlphaFactor,
+      blendDst: THREE.OneMinusSrcAlphaFactor,
+      depthWrite: false,
+      depthTest: true,
+      transparent: true,
+      side: THREE.BackSide,
+    });
+    const materialFrontSide = new THREE.MeshBasicMaterial({
+      blending: THREE.NormalBlending,
+      blendEquation: THREE.AddEquation,
+      blendSrc: THREE.SrcAlphaFactor,
+      blendDst: THREE.OneMinusSrcAlphaFactor,
+      depthWrite: false,
+      depthTest: true,
+      transparent: true,
+      side: THREE.FrontSide,
+    });
+    materialFirstPass.map = n.material.map;
+    materialBackSide.map = n.material.map;
+    materialFrontSide.map = n.material.map;
+    materialFirstPass.name=n.material.name+"materialFirstPass";
+    materialBackSide.name=n.material.name+"materialBackSide";
+    materialFrontSide.name=n.material.name+"materialFrontSide";
+    let mesh = n;
+    let mesh2 = n.clone();
+    n.parent.add(mesh2);
+    let mesh3 = n.clone();
+    n.parent.add(mesh3);
+    mesh.material = materialFirstPass;
+    mesh2.material = materialBackSide;
+    mesh2.renderOrder = n.renderOrder + 1;
+    mesh3.material = materialFrontSide;
+    mesh3.renderOrder = n.renderOrder + 2;
+  });
+}
+function resetSSSMaterial(n) {
+  if (n.material.name.indexOf("head_sss") >= 0 || n.material.name.indexOf("body_sss") >= 0) {
+    const shader = SubsurfaceScatteringShader;
+    var material = new THREE.ShaderMaterial({
+      uniforms: THREE.UniformsUtils.clone(SubsurfaceScatteringShader.uniforms),
+      vertexShader: shader.vertexShader,
+      fragmentShader: shader.fragmentShader,
+    });
+    var source = n.material;
+    var m: any = material;
+    m.blending = source.blending;
+    m.side = source.side;
+    m.vertexColors = source.vertexColors;
+    m.opacity = source.opacity;
+    m.transparent = source.transparent;
+    m.blendSrc = source.blendSrc;
+    m.blendDst = source.blendDst;
+    m.blendEquation = source.blendEquation;
+    m.blendSrcAlpha = source.blendSrcAlpha;
+    m.blendDstAlpha = source.blendDstAlpha;
+    m.blendEquationAlpha = source.blendEquationAlpha;
+    m.depthFunc = source.depthFunc;
+    m.depthTest = source.depthTest;
+    m.depthWrite = source.depthWrite;
+    m.stencilWriteMask = source.stencilWriteMask;
+    m.stencilFunc = source.stencilFunc;
+    m.stencilRef = source.stencilRef;
+    m.stencilFuncMask = source.stencilFuncMask;
+    m.stencilFail = source.stencilFail;
+    m.stencilZFail = source.stencilZFail;
+    m.stencilZPass = source.stencilZPass;
+    m.stencilWrite = source.stencilWrite;
+    const srcPlanes = source.clippingPlanes;
+    let dstPlanes = null;
+    if (srcPlanes !== null) {
+      const n = srcPlanes.length;
+      dstPlanes = new Array(n);
+
+      for (let i = 0; i !== n; ++i) {
+        dstPlanes[i] = srcPlanes[i].clone();
+      }
+    }
+    m.clippingPlanes = dstPlanes;
+    m.clipIntersection = source.clipIntersection;
+    m.clipShadows = source.clipShadows;
+    m.shadowSide = source.shadowSide;
+    m.colorWrite = source.colorWrite;
+    m.precision = source.precision;
+    m.polygonOffset = source.polygonOffset;
+    m.polygonOffsetFactor = source.polygonOffsetFactor;
+    m.polygonOffsetUnits = source.polygonOffsetUnits;
+    m.dithering = source.dithering;
+    m.alphaTest = source.alphaTest;
+    m.alphaToCoverage = source.alphaToCoverage;
+    m.premultipliedAlpha = source.premultipliedAlpha;
+    m.visible = source.visible;
+    m.toneMapped = source.toneMapped;
+    m.userData = JSON.parse(JSON.stringify(source.userData));
+
+    material.defines = { STANDARD: "" };
+
+    m.color = source.color.clone();
+    m.roughness = source.roughness;
+    m.metalness = source.metalness;
+    m.map = source.map;
+    m.lightMap = source.lightMap;
+    m.lightMapIntensity = source.lightMapIntensity;
+    m.aoMap = source.aoMap;
+    m.aoMapIntensity = source.aoMapIntensity;
+    m.emissive = source.emissive.clone();
+    m.emissiveMap = source.emissiveMap;
+    m.emissiveIntensity = source.emissiveIntensity;
+    m.bumpMap = source.bumpMap;
+    m.bumpScale = source.bumpScale;
+    m.normalMap = source.normalMap;
+    m.normalMapType = source.normalMapType;
+    m.normalScale = source.normalScale.clone();
+    m.displacementMap = source.displacementMap;
+    m.displacementScale = source.displacementScale;
+    m.displacementBias = source.displacementBias;
+    m.roughnessMap = source.roughnessMap;
+    m.metalnessMap = source.metalnessMap;
+    m.alphaMap = source.alphaMap;
+    m.envMap = source.envMap;
+    m.envMapIntensity = source.envMapIntensity;
+    m.wireframe = source.wireframe;
+    m.wireframeLinewidth = source.wireframeLinewidth;
+    m.wireframeLinecap = source.wireframeLinecap;
+    m.wireframeLinejoin = source.wireframeLinejoin;
+    m.flatShading = source.flatShading;
+    m.fog = source.fog;
+    m.isMeshStandardMaterial = true;
+
+    console.log(n.material);
+    material.name = n.material.name;
+    n.material = material;
+    console.log(n.material);
+  }
+}

package/src/lib/core/utils/convert.ts

@@ -0,0 +1,124 @@
+/* eslint-disable */
+import * as THREE from "three";
+let bodyMorphTargetDictionary = {};
+let teethMorphTargetDictionary = {};
+export let bodyMeshName;
+export let Tooth_downMeshName;
+export function setBodyMorphTargetDictionary(name, map) {
+  bodyMorphTargetDictionary = map;
+  console.log(bodyMorphTargetDictionary);
+  bodyMeshName = name;
+}
+export function setTeethMorphTargetDictionary(name, map) {
+  teethMorphTargetDictionary = map;
+  Tooth_downMeshName = name;
+  console.log(teethMorphTargetDictionary);
+}
+
+/**
+ *
+ * @param { object } fp 动画文件json结构的描述
+ * @param {boolean} isEmotion 是否为表情类型的动画
+ * @returns { AnimationClip }
+ * @desc 通过将JSON结构的描述转化为 THREEJS 的AnimationClip
+ */
+export default function Convert(fp, isEmotion = false) {
+  // console.log(fp);
+  const kfs = new Array<THREE.KeyframeTrack>();
+  const arry = fp["CurveInfos"] as Array<JSON>;
+  for (let i = 0; i < arry.length; i++) {
+    const element = arry[i];
+    const str = element["PathKey"] as string;
+    const index = str.indexOf("Transform");
+    if (index >= 0) {
+      if (str.indexOf(".x") >= 0 && (!isEmotion || str.indexOf(".eye") >= 0)) {
+        const s = str.split(":");
+        const s2 = s[0].split("/");
+        const boneName = s2[s2.length - 1];
+        let trackName = boneName + ".";
+        if (str.indexOf("Position") >= 0) {
+          trackName = trackName + "position";
+        }
+        if (str.indexOf("Scale") >= 0) {
+          trackName = trackName + "scale";
+        }
+        if (str.indexOf("Rotation") >= 0) {
+          trackName = trackName + "quaternion";
+        }
+        const keys = element["Keys"] as Array<JSON>;
+        const times = keys.map((k) => k["Time"] as number);
+        const xs = keys.map((k) => k["Value"] as number);
+        const ys = (arry[i + 1]["Keys"] as Array<JSON>).map((k) => k["Value"] as number);
+        const zs = (arry[i + 2]["Keys"] as Array<JSON>).map((k) => k["Value"] as number);
+        let vs = new Float32Array();
+        if (str.indexOf("Position") > 0) {
+          vs = new Float32Array(xs.length * 3);
+          for (var j = 0; j < xs.length; j++) {
+            vs[j * 3] = -xs[j];
+            vs[j * 3 + 1] = ys[j];
+            vs[j * 3 + 2] = zs[j];
+          }
+          var track = new THREE.KeyframeTrack(trackName, times, vs, THREE.InterpolateLinear);
+        } else if (str.indexOf("Scale") > 0) {
+          vs = new Float32Array(xs.length * 3);
+          for (var j = 0; j < xs.length; j++) {
+            vs[j * 3] = xs[j];
+            vs[j * 3 + 1] = ys[j];
+            vs[j * 3 + 2] = zs[j];
+          }
+          var track = new THREE.KeyframeTrack(trackName, times, vs, THREE.InterpolateLinear);
+        } else {
+          var ws = arry[i + 3]["Keys"].map((k) => k["Value"]);
+          var vs2 = [];
+          for (var j = 0; j < xs.length; j++) {
+            var q = new THREE.Quaternion(xs[j], ys[j], zs[j], ws[j]);
+            vs2[j * 4] = q.x;
+            vs2[j * 4 + 1] = -q.y;
+            vs2[j * 4 + 2] = -q.z;
+            vs2[j * 4 + 3] = q.w;
+          }
+          var track = new THREE.QuaternionKeyframeTrack(
+            trackName,
+            times,
+            vs2,
+            THREE.InterpolateLinear
+          );
+          track.ValueTypeName = "quaternion";
+          kfs.push(track);
+        }
+      }
+    } else if (str.indexOf("Skinned") > 0) {
+      const s = str.split(":");
+      const s2 = s[0].split("/");
+      const boneName = s2[s2.length - 1];
+      if (boneName == "body") {
+        /////////////////////////////////liujun
+        const trackName =
+          bodyMeshName +
+          ".morphTargetInfluences[" +
+          bodyMorphTargetDictionary[s[2].substring(11)] +
+          "]";
+        const keys = element["Keys"] as Array<JSON>;
+        const times = keys.map((k) => k["Time"] as number);
+        const values = keys.map((k) => ((k["Value"] as number) / 100) * 0.65);
+        const track = new THREE.KeyframeTrack(trackName, times, values);
+        kfs.push(track);
+      }
+      if (boneName == "tooth_down") {
+        const trackName =
+          Tooth_downMeshName +
+          ".morphTargetInfluences[" +
+          teethMorphTargetDictionary[s[2].substring(11)] +
+          "]";
+        const keys = element["Keys"] as Array<JSON>;
+        const times = keys.map((k) => k["Time"] as number);
+        const values = keys.map((k) => ((k["Value"] as number) / 100) * 0.65);
+        const track = new THREE.KeyframeTrack(trackName, times, values);
+        kfs.push(track);
+      }
+    }
+  }
+  const ac = new THREE.AnimationClip(fp["name"], undefined, kfs, THREE.NormalAnimationBlendMode);
+
+  return ac;
+}

package/src/lib/core/utils/downloadAnimation.ts

@@ -0,0 +1,117 @@
+import * as THREE from "three";
+import { downloadData } from "./downloadData";
+import * as fflate from "fflate";
+import { getSuffixName, largeUint8ArrayToString } from ".";
+import cryptoModule from "./metacrypto.js";
+export async function downloadAnimation(animationName, geometryName) {
+  let arraybuffer: ArrayBuffer;
+  // eslint-disable-next-line prefer-const
+  arraybuffer = (await downloadData(animationName, "arraybuffer")) as ArrayBuffer;
+  console.log(arraybuffer);
+  const dataView = new DataView(arraybuffer);
+  let offset = 0;
+  const nameLen = dataView.getInt32(offset, true);
+  offset += 4;
+  console.log(nameLen);
+  offset += nameLen;
+  const length = dataView.getFloat32(offset, true);
+  offset += 4;
+  console.log(length);
+  const num = dataView.getUint32(offset, true);
+  offset += 4;
+  console.log(num);
+
+  const dict = {};
+
+  for (let i = 0; i < num; i++) {
+    const time = dataView.getFloat32(offset, true);
+    offset += 4;
+    const posLen = dataView.getUint32(offset, true);
+    offset += 4;
+    const pos = [];
+    const mag = [];
+    for (let j = 0; j < posLen; j++) {
+      const posj = dataView.getUint16(offset, true);
+      offset += 2;
+      const magj = dataView.getFloat32(offset, true);
+      offset += 4;
+      if (dict[posj] == undefined) {
+        dict[posj] = {};
+        dict[posj].times = [];
+        dict[posj].values = [];
+      }
+      dict[posj].times.push(time);
+      dict[posj].values.push(magj * 0.65);
+    }
+  }
+  console.log(dict);
+  const kfs = new Array<THREE.KeyframeTrack>();
+  for (const key in dict) {
+    const track = new THREE.KeyframeTrack(
+      geometryName + ".morphTargetInfluences[" + key + "]",
+      dict[key].times,
+      dict[key].values,
+      THREE.InterpolateLinear
+    );
+    kfs.push(track);
+  }
+  const ac = new THREE.AnimationClip(animationName, -1, kfs, THREE.NormalAnimationBlendMode);
+  return ac;
+}
+
+/**
+ *
+ * @param animateName 动画名称
+ * @param baseUrl 地址前缀
+ * @returns {Promise<object>}
+ * 通过动画名称加载动画的描述，得到的是JSON结构的数据
+ */
+export const loadAnimationData = async function (
+  animateName: string,
+  baseUrl = "//img.metaworks.cn/webgl/app"
+): Promise<object> {
+  let url: string;
+  if (!animateName) {
+    return Promise.reject("没有对应的动画名称");
+  }
+  if (animateName.startsWith("http")) {
+    url = animateName;
+  } else {
+    url = `${baseUrl}/${animateName}`;
+  }
+
+  const result = (await downloadData(url, "arraybuffer")) as ArrayBuffer;
+  const buffer = new Uint8Array(result) as Uint8Array;
+  let fileBuffer = await new Promise((resolve) => {
+    const unzipper = new fflate.Unzip();
+    unzipper.register(fflate.UnzipInflate);
+    unzipper.onfile = (file) => {
+      // file.name is a string, file is a stream
+      if (getSuffixName(file.name) == "json") {
+        return;
+      }
+      file.ondata = (err, dat, final) => {
+        // Stream output here
+        resolve(dat);
+      };
+      console.log("Reading:", file.name);
+      // File sizes are sometimes not set if the ZIP file did not encode
+      // them, so you may want to check that file.size != undefined
+      console.log("Compressed size", file.size);
+      console.log("Decompressed size", file.originalSize);
+
+      file.start();
+    };
+    unzipper.push(buffer, true);
+  });
+
+  fileBuffer = new Uint8Array(fileBuffer as any);
+
+  let s = await largeUint8ArrayToString(fileBuffer);
+  if (s[0] != "{") {
+    const arraybuffer = await cryptoModule.decryptData(fileBuffer);
+    s = await largeUint8ArrayToString(arraybuffer);
+  }
+  const json = JSON.parse(s);
+  return json;
+};

package/src/lib/core/utils/downloadData.ts

@@ -0,0 +1,20 @@
+const downloadData = function (url, type) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.responseType = type;
+    xhr.onreadystatechange = function () {
+      if (xhr.readyState == 4) {
+        const status = xhr.status;
+        if (status >= 200 && status < 300) {
+          resolve(xhr.response);
+        } else {
+          reject(status);
+        }
+      }
+    };
+    xhr.open("GET", url, true);
+    xhr.send(null);
+  });
+};
+
+export { downloadData };

package/src/lib/core/utils/index.ts

@@ -0,0 +1,59 @@
+/**
+ *
+ * @param { string } name 文件名称
+ * @returns { string } 后缀名
+ */
+export const getSuffixName = (name) => {
+  const splits = name.split(".");
+  return splits[splits.length - 1];
+};
+
+export function Uint8ArrayToString(fileData) {
+  let dataString = "";
+  for (let i = 0; i < fileData.length; i++) {
+    dataString += String.fromCharCode(fileData[i]);
+  }
+
+  return dataString;
+}
+
+export async function largeUint8ArrayToString(uint8arr): Promise<string> {
+  return new Promise((resolve) => {
+    const blob = new Blob([uint8arr]);
+    const reader = new FileReader();
+    reader.onload = function (e) {
+      resolve(e.target.result as string);
+    };
+    reader.readAsText(blob);
+  });
+}
+
+export const b64toBlob = (b64Data, contentType = "", sliceSize = 512) => {
+  const byteCharacters = atob(b64Data);
+  const byteArrays = [];
+
+  for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
+    const slice = byteCharacters.slice(offset, offset + sliceSize);
+
+    const byteNumbers = new Array(slice.length);
+    for (let i = 0; i < slice.length; i++) {
+      byteNumbers[i] = slice.charCodeAt(i);
+    }
+
+    const byteArray = new Uint8Array(byteNumbers);
+    byteArrays.push(byteArray);
+  }
+
+  const blob = new Blob(byteArrays, { type: contentType });
+  return blob;
+};
+
+export const splitb64 = (str: string): { b64Data: string; contentType: string } => {
+  const prefix = str.split(";")[0];
+  const contentType = prefix.split("data:")[1];
+  const b64Data = str.split(",")[1];
+  return {
+    b64Data,
+    contentType,
+  };
+};

package/src/lib/core/utils/metacrypto.js

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+
+import wasm from "@/assets/metacrypto.wasm";
+const importObject = {
+  wasi_snapshot_preview1: { proc_exit: () => {} },
+};
+let loadPromise = wasm(importObject);
+class CryptoModule {
+  constructor() {
+    this.initPromise = new Promise((_resolve) => {});
+    this.info = {
+      wasi_snapshot_preview1: { proc_exit: () => {} },
+    };
+    this.loadWasm();
+  }
+  loadWasm() {
+    this.initPromise = loadPromise;
+  }
+  decryptData(data) {
+    return this.initPromise.then(({ instance }) => {
+      let {
+        cppDecodeEncrypt,
+        cppGetReadDataLength,
+        cppGetWriteDataPtr,
+        cppSetEncryptKey,
+        cppEncodeEncrypt,
+        memory,
+      } = instance.exports;
+      let Int8View = new Uint8Array(memory.buffer);
+      if (ArrayBuffer.isView(data)) {
+        //if(true){
+        var intdata = new Uint8Array(data);
+        let bytesSize = intdata.length;
+
+        let writeDataOffset = cppGetWriteDataPtr(bytesSize);
+        Int8View.set(intdata, writeDataOffset);
+
+        let readDataOffset = cppDecodeEncrypt(bytesSize);
+        let readDataLength = cppGetReadDataLength();
+        let out_intdata = Int8View.subarray(readDataOffset, readDataOffset + readDataLength);
+
+        return out_intdata.slice(0);
+      }
+    });
+  }
+}
+
+let cryptoModule = new CryptoModule();
+export default cryptoModule;

package/src/lib/globals.d.ts

@@ -0,0 +1,7 @@
+declare module "*.svg";
+declare module "*.png";
+declare module "*.jpg";
+declare module "*.jpeg";
+declare module "*.gif";
+declare module "*.bmp";
+declare module "*.tiff";

package/src/lib/index.ts

@@ -0,0 +1,7 @@
+import * as core from "./core";
+
+const MMFT = {
+  core,
+};
+
+export default MMFT;

package/tsconfig.dist.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declarationDir": "./types"
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "strict": false,
+    "allowJs": true,
+    "jsx": "preserve",
+    "declaration": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "useDefineForClassFields": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "types": ["webpack-env", "jest"],
+    "paths": {
+      "@/*": ["src/*"]
+    },
+    "lib": ["esnext", "dom", "dom.iterable", "scripthost"]
+  },
+  "include": [
+    "examples/**/*.ts",
+    "examples/**/*.tsx",
+    "examples/**/*.vue",
+    "tests/**/*.ts",
+    "tests/**/*.tsx",
+    "src/**/*.ts"
+  ],
+  "exclude": ["node_modules"]
+}