@plattar/plattar-ar-adapter 1.121.1 → 1.122.4

package/dist/ar/raw-ar.d.ts

@@ -0,0 +1,30 @@
+import { LauncherAR } from "./launcher-ar";
+/**
+ * Allows launching AR Experiences provided a single remote 3D Model file
+ */
+export declare class RawAR extends LauncherAR {
+    private readonly _modelLocation;
+    private _ar;
+    constructor(modelLocation?: string | undefined | null);
+    get modelLocation(): string;
+    /**
+     * Initialise the RawAR instance. This returns a Promise that resolves
+     * successfully if initialisation is successful, otherwise it will fail.
+     *
+     * filure can occur for a number of reasons but it generally means that AR
+     * cannot be performed.
+     */
+    init(): Promise<LauncherAR>;
+    /**
+     * Initialise and launch with a single function call. this is mostly for convenience.
+     * Use .init() and .start() separately for fine-grained control
+     */
+    launch(): Promise<void>;
+    /**
+     * Launches the internal AR instance using an appropriate version of AR Viewers
+     */
+    start(): void;
+    canQuicklook(): boolean;
+    canRealityViewer(): boolean;
+    canSceneViewer(): boolean;
+}

package/dist/ar/raw-ar.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawAR = void 0;
+const util_1 = require("../util/util");
+const quicklook_viewer_1 = __importDefault(require("../viewers/quicklook-viewer"));
+const reality_viewer_1 = __importDefault(require("../viewers/reality-viewer"));
+const scene_viewer_1 = __importDefault(require("../viewers/scene-viewer"));
+const launcher_ar_1 = require("./launcher-ar");
+/**
+ * Allows launching AR Experiences provided a single remote 3D Model file
+ */
+class RawAR extends launcher_ar_1.LauncherAR {
+    constructor(modelLocation = null) {
+        super();
+        if (!modelLocation) {
+            throw new Error("RawAR.constructor(modelLocation) - modelLocation must be defined");
+        }
+        const lowerLoc = modelLocation.toLowerCase();
+        if (lowerLoc.endsWith("usdz") || lowerLoc.endsWith("glb") || lowerLoc.endsWith("gltf") || lowerLoc.endsWith("reality")) {
+            this._modelLocation = modelLocation;
+            this._ar = null;
+        }
+        else {
+            throw new Error("RawAR.constructor(modelLocation) - modelLocation must be one of gltf, glb, usdz or reality");
+        }
+    }
+    get modelLocation() {
+        return this._modelLocation;
+    }
+    /**
+     * Initialise the RawAR instance. This returns a Promise that resolves
+     * successfully if initialisation is successful, otherwise it will fail.
+     *
+     * filure can occur for a number of reasons but it generally means that AR
+     * cannot be performed.
+     */
+    init() {
+        return new Promise((accept, reject) => {
+            if (!util_1.Util.canAugment()) {
+                return reject(new Error("RawAR.init() - cannot proceed as AR not available in context"));
+            }
+            const modelLocation = this._modelLocation;
+            const lowerLoc = modelLocation.toLowerCase();
+            // we need to define our AR module here
+            // we are in Safari/Quicklook mode here
+            if (util_1.Util.isSafari() || util_1.Util.isChromeOnIOS()) {
+                // load the reality experience if dealing with reality file
+                if (lowerLoc.endsWith("reality") && util_1.Util.canRealityViewer()) {
+                    this._ar = new reality_viewer_1.default();
+                    this._ar.modelUrl = modelLocation;
+                    return accept(this);
+                }
+                // load the usdz experience if dealing with usdz file
+                if (lowerLoc.endsWith("usdz") && util_1.Util.canQuicklook()) {
+                    this._ar = new quicklook_viewer_1.default();
+                    this._ar.modelUrl = modelLocation;
+                    return accept(this);
+                }
+                return reject(new Error("RawAR.init() - cannot proceed as model is not a .usdz or .reality file"));
+            }
+            // check android
+            if (util_1.Util.canSceneViewer()) {
+                if (lowerLoc.endsWith("glb") || lowerLoc.endsWith("gltf")) {
+                    this._ar = new scene_viewer_1.default();
+                    this._ar.modelUrl = modelLocation;
+                    return accept(this);
+                }
+                return reject(new Error("RawAR.init() - cannot proceed as model is not a .glb or .gltf file"));
+            }
+            // otherwise, we didn't have AR available - it should never really reach this stage as this should be caught
+            // earlier in the process
+            return reject(new Error("RawAR.init() - could not initialise AR correctly, check values"));
+        });
+    }
+    /**
+     * Initialise and launch with a single function call. this is mostly for convenience.
+     * Use .init() and .start() separately for fine-grained control
+     */
+    launch() {
+        return new Promise((accept, reject) => {
+            this.init().then((value) => {
+                value.start();
+                return accept();
+            }).catch(reject);
+        });
+    }
+    /**
+     * Launches the internal AR instance using an appropriate version of AR Viewers
+     */
+    start() {
+        if (!this._ar) {
+            throw new Error("RawAR.start() - cannot proceed as AR instance is null");
+        }
+        // this was initialised via the init() function
+        this._ar.start();
+    }
+    canQuicklook() {
+        return this._ar && this._ar.nodeType === "Quick Look" ? true : false;
+    }
+    canRealityViewer() {
+        return this._ar && this._ar.nodeType === "Reality Viewer" ? true : false;
+    }
+    canSceneViewer() {
+        return this._ar && this._ar.nodeType === "Scene Viewer" ? true : false;
+    }
+}
+exports.RawAR = RawAR;

package/dist/embed/plattar-embed.d.ts

@@ -4,6 +4,9 @@ import { LauncherAR } from "../ar/launcher-ar";
  * of Plattar related content
  */
 export default class PlattarEmbed extends HTMLElement {
+    private _currentState;
+    private _currentType;
+    private _qrCodeOptions;
     private _sceneID;
     private _productID;
     private _variationID;
@@ -19,4 +22,9 @@ export default class PlattarEmbed extends HTMLElement {
     startAR(): Promise<void>;
     startViewer(): Promise<HTMLElement>;
     startQRCode(options?: any | undefined | null): Promise<HTMLElement>;
+    /**
+     * This is called by the observer if any of the embed attributes have changed
+     * based on the state of the embed, we update the internal structure accordingly
+     */
+    private _OnAttributesUpdated;
 }

package/dist/embed/plattar-embed.js

@@ -2,6 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plattar_api_1 = require("@plattar/plattar-api");
 const product_ar_1 = require("../ar/product-ar");
+const plattar_services_1 = require("@plattar/plattar-services");
+const util_1 = require("../util/util");
+const raw_ar_1 = require("../ar/raw-ar");
+/**
+ * This tracks the current state of the Embed
+ */
+var EmbedState;
+(function (EmbedState) {
+    EmbedState[EmbedState["None"] = 0] = "None";
+    EmbedState[EmbedState["SceneViewer"] = 1] = "SceneViewer";
+    EmbedState[EmbedState["ProductViewer"] = 2] = "ProductViewer";
+    EmbedState[EmbedState["ConfiguratorViewer"] = 3] = "ConfiguratorViewer";
+    EmbedState[EmbedState["ProductAR"] = 4] = "ProductAR";
+    EmbedState[EmbedState["QRCode"] = 5] = "QRCode";
+})(EmbedState || (EmbedState = {}));
+/**
+ * This tracks the current embed type
+ */
+var EmbedType;
+(function (EmbedType) {
+    EmbedType[EmbedType["Viewer"] = 0] = "Viewer";
+    EmbedType[EmbedType["Configurator"] = 1] = "Configurator";
+})(EmbedType || (EmbedType = {}));
 /**
  * This is the primary <plattar-embed /> node that allows easy embedding
  * of Plattar related content
@@ -9,6 +32,15 @@ const product_ar_1 = require("../ar/product-ar");
 class PlattarEmbed extends HTMLElement {
     constructor() {
         super();
+        // this is the current state of the embed, none by default
+        this._currentState = EmbedState.None;
+        // this is the current embed type, viewer by default
+        this._currentType = EmbedType.Viewer;
+        this._qrCodeOptions = {
+            color: "#101721",
+            qrType: "default",
+            margin: 0
+        };
         this._sceneID = null;
         this._productID = null;
         this._variationID = null;
@@ -22,6 +54,48 @@ class PlattarEmbed extends HTMLElement {
         return this._viewer;
     }
     connectedCallback() {
+        const embedType = this.hasAttribute("embed-type") ? this.getAttribute("embed-type") : "viewer";
+        if (embedType) {
+            switch (embedType.toLowerCase()) {
+                case "viewer":
+                    this._currentType = EmbedType.Viewer;
+                    break;
+                case "configurator":
+                    this._currentType = EmbedType.Configurator;
+                    break;
+                default:
+                    this._currentType = EmbedType.Viewer;
+            }
+        }
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === "attributes") {
+                    const sceneID = this.hasAttribute("scene-id") ? this.getAttribute("scene-id") : null;
+                    const productID = this.hasAttribute("product-id") ? this.getAttribute("product-id") : null;
+                    const variationID = this.hasAttribute("variation-id") ? this.getAttribute("variation-id") : null;
+                    let updated = false;
+                    if (sceneID !== this._sceneID) {
+                        this._sceneID = sceneID;
+                        updated = true;
+                    }
+                    if (productID !== this._productID) {
+                        this._productID = productID;
+                        updated = true;
+                    }
+                    if (variationID !== this._variationID) {
+                        this._variationID = variationID;
+                        updated = true;
+                    }
+                    if (updated) {
+                        // re-render based on internal state
+                        this._OnAttributesUpdated();
+                    }
+                }
+            });
+        });
+        observer.observe(this, {
+            attributes: true
+        });
         const server = this.hasAttribute("server") ? this.getAttribute("server") : "production";
         plattar_api_1.Server.create(plattar_api_1.Server.match(server || "production"));
         if (server) {
@@ -69,10 +143,73 @@ class PlattarEmbed extends HTMLElement {
             if (!this._isReady) {
                 return reject(new Error("PlattarEmbed.initAR() - cannot execute as page has not loaded yet"));
             }
-            // if scene is not set but product is, then use ProductAR
-            if (!this._sceneID && this._productID) {
-                const product = new product_ar_1.ProductAR(this._productID, this._variationID);
-                return product.init().then(accept).catch(reject);
+            if (!util_1.Util.canAugment()) {
+                return reject(new Error("PlattarEmbed.initAR() - cannot proceed as AR not available in context"));
+            }
+            if (this._currentType === EmbedType.Viewer) {
+                // if scene is not set but product is, then use ProductAR
+                if (!this._sceneID && this._productID) {
+                    const product = new product_ar_1.ProductAR(this._productID, this._variationID);
+                    return product.init().then(accept).catch(reject);
+                }
+                // If Product is set (under any scenario) then use ProductAR
+                // NOTE: At some point this should check for Scenes when SceneAR
+                // is implemented
+                if (this._productID) {
+                    const product = new product_ar_1.ProductAR(this._productID, this._variationID);
+                    return product.init().then(accept).catch(reject);
+                }
+            }
+            if (this._currentType === EmbedType.Configurator) {
+                // if scene ID is available and the state is a configurator viewer
+                // we can use the real-time configurator state to launch the AR view
+                const viewer = this.viewer;
+                if (viewer && this._sceneID && this._currentState === EmbedState.ConfiguratorViewer) {
+                    let output = "glb";
+                    if (util_1.Util.isSafari() || util_1.Util.isChromeOnIOS()) {
+                        output = "usdz";
+                    }
+                    viewer.messenger.getARFile(output).then((result) => {
+                        const rawAR = new raw_ar_1.RawAR(result.filename);
+                        return rawAR.init().then(accept).catch(reject);
+                    }).catch(reject);
+                }
+                const configState = this.hasAttribute("config-state") ? this.getAttribute("config-state") : null;
+                // otherwise scene ID is available to the viewer is not launched
+                // we can use the static configuration state to launch the AR view
+                if (this._sceneID && configState) {
+                    try {
+                        const decodedb64State = atob(configState);
+                        const state = JSON.parse(decodedb64State);
+                        if (state.meta) {
+                            const sceneProductIndex = state.meta.scene_product_index || 0;
+                            const variationIndex = state.meta.product_variation_index || 1;
+                            const states = state.states || [];
+                            if (states.length > 0) {
+                                const configurator = new plattar_services_1.Configurator();
+                                states.forEach((productState) => {
+                                    configurator.addSceneProduct(productState[sceneProductIndex], productState[variationIndex]);
+                                });
+                                if (util_1.Util.isSafari() || util_1.Util.isChromeOnIOS()) {
+                                    configurator.output = "usdz";
+                                }
+                                if (util_1.Util.canSceneViewer()) {
+                                    configurator.output = "glb";
+                                }
+                                configurator.server = this._server;
+                                return configurator.get().then((result) => {
+                                    const rawAR = new raw_ar_1.RawAR(result.filename);
+                                    rawAR.init().then(accept).catch(reject);
+                                }).catch(reject);
+                            }
+                            return reject(new Error("PlattarEmbed.initAR() - invalid config-state does not have any product states"));
+                        }
+                        return reject(new Error("PlattarEmbed.initAR() - invalid config-state for configurator"));
+                    }
+                    catch (err) {
+                        return reject(err);
+                    }
+                }
             }
             // otherwise, scene was set so use SceneAR
             if (this._sceneID) {
@@ -101,19 +238,50 @@ class PlattarEmbed extends HTMLElement {
                 this._viewer.remove();
                 this._viewer = null;
             }
-            // if scene is set, we use <plattar-viewer /> node from plattar-web
-            if (this._sceneID) {
+            // if scene is set and embed is a viewer type, we use <plattar-viewer /> node from plattar-web
+            if (this._sceneID && this._currentType === EmbedType.Viewer) {
                 const viewer = document.createElement("plattar-viewer");
                 viewer.setAttribute("width", this._width);
                 viewer.setAttribute("height", this._height);
                 viewer.setAttribute("server", this._server);
                 viewer.setAttribute("scene-id", this._sceneID);
+                if (this._productID) {
+                    viewer.setAttribute("product-id", this._productID);
+                }
+                if (this._variationID) {
+                    viewer.setAttribute("variation-id", this._variationID);
+                }
+                viewer.onload = () => {
+                    return accept(viewer);
+                };
+                const shadow = this.shadowRoot || this.attachShadow({ mode: 'open' });
+                shadow.append(viewer);
+                this._viewer = viewer;
+                this._currentState = EmbedState.SceneViewer;
+                return;
+            }
+            // if scene is set and embed is a configurator type, we use <plattar-configurator /> node from plattar-web
+            if (this._sceneID && this._currentType === EmbedType.Configurator) {
+                const viewer = document.createElement("plattar-configurator");
+                viewer.setAttribute("width", this._width);
+                viewer.setAttribute("height", this._height);
+                viewer.setAttribute("server", this._server);
+                viewer.setAttribute("scene-id", this._sceneID);
+                const configState = this.hasAttribute("config-state") ? this.getAttribute("config-state") : null;
+                const showAR = this.hasAttribute("show-ar") ? this.getAttribute("show-ar") : null;
+                if (configState) {
+                    viewer.setAttribute("config-state", configState);
+                }
+                if (showAR) {
+                    viewer.setAttribute("show-ar", showAR);
+                }
                 viewer.onload = () => {
                     return accept(viewer);
                 };
                 const shadow = this.shadowRoot || this.attachShadow({ mode: 'open' });
                 shadow.append(viewer);
                 this._viewer = viewer;
+                this._currentState = EmbedState.ConfiguratorViewer;
                 return;
             }
             // if product is set, we use <plattar-product /> node from plattar-web
@@ -132,6 +300,7 @@ class PlattarEmbed extends HTMLElement {
                 const shadow = this.shadowRoot || this.attachShadow({ mode: 'open' });
                 shadow.append(viewer);
                 this._viewer = viewer;
+                this._currentState = EmbedState.ProductViewer;
                 return;
             }
             return reject(new Error("PlattarEmbed.startViewer() - minimum required attributes not set, use scene-id or product-id as a minimum"));
@@ -142,17 +311,48 @@ class PlattarEmbed extends HTMLElement {
             if (!this._isReady) {
                 return reject(new Error("PlattarEmbed.startQRCode() - cannot execute as page has not loaded yet"));
             }
-            const opt = options || {
-                color: "#101721",
-                qrType: "default",
-                margin: 0
-            };
+            const opt = options || this._qrCodeOptions;
+            // reset instance for later use
+            this._qrCodeOptions = opt;
             if (this._viewer) {
                 this._viewer.remove();
                 this._viewer = null;
             }
-            // if scene is set, we embed a QR code that takes us to viewer.html
-            if (this._sceneID) {
+            // if scene is set and embed type is viewer
+            // we embed a QR code that takes us to viewer.html
+            if (this._sceneID && this._currentType == EmbedType.Viewer) {
+                const viewer = document.createElement("plattar-qrcode");
+                viewer.setAttribute("width", this._width);
+                viewer.setAttribute("height", this._height);
+                if (opt.color) {
+                    viewer.setAttribute("color", opt.color);
+                }
+                if (opt.margin) {
+                    viewer.setAttribute("margin", "" + opt.margin);
+                }
+                if (opt.qrType) {
+                    viewer.setAttribute("qr-type", opt.qrType);
+                }
+                let dst = plattar_api_1.Server.location().base + "renderer/viewer.html?scene_id=" + this._sceneID;
+                if (this._productID) {
+                    dst += "&productId=" + this._productID;
+                }
+                if (this._variationID) {
+                    dst += "&variationId=" + this._variationID;
+                }
+                viewer.setAttribute("url", opt.url || dst);
+                viewer.onload = () => {
+                    return accept(viewer);
+                };
+                const shadow = this.shadowRoot || this.attachShadow({ mode: 'open' });
+                shadow.append(viewer);
+                this._viewer = viewer;
+                this._currentState = EmbedState.QRCode;
+                return;
+            }
+            // if scene is set and embed type is configurator
+            // we embed a QR code that takes us to configurator.html
+            if (this._sceneID && this._currentType == EmbedType.Configurator) {
                 const viewer = document.createElement("plattar-qrcode");
                 viewer.setAttribute("width", this._width);
                 viewer.setAttribute("height", this._height);
@@ -165,14 +365,23 @@ class PlattarEmbed extends HTMLElement {
                 if (opt.qrType) {
                     viewer.setAttribute("qr-type", opt.qrType);
                 }
-                const dst = plattar_api_1.Server.location().base + "renderer/viewer.html?scene_id=" + this._sceneID;
-                viewer.setAttribute("url", dst);
+                let dst = plattar_api_1.Server.location().base + "renderer/configurator.html?scene_id=" + this._sceneID;
+                const configState = this.hasAttribute("config-state") ? this.getAttribute("config-state") : null;
+                const showAR = this.hasAttribute("show-ar") ? this.getAttribute("show-ar") : null;
+                if (configState) {
+                    dst += "&config_state=" + configState;
+                }
+                if (showAR) {
+                    dst += "&show_ar=" + showAR;
+                }
+                viewer.setAttribute("url", opt.url || dst);
                 viewer.onload = () => {
                     return accept(viewer);
                 };
                 const shadow = this.shadowRoot || this.attachShadow({ mode: 'open' });
                 shadow.append(viewer);
                 this._viewer = viewer;
+                this._currentState = EmbedState.QRCode;
                 return;
             }
             // if product is set, we embed a QR code that takes us to product.html
@@ -193,17 +402,50 @@ class PlattarEmbed extends HTMLElement {
                 if (this._variationID) {
                     dst += "&variation_id=" + this._variationID;
                 }
-                viewer.setAttribute("url", dst);
+                viewer.setAttribute("url", opt.url || dst);
                 viewer.onload = () => {
                     return accept(viewer);
                 };
                 const shadow = this.shadowRoot || this.attachShadow({ mode: 'open' });
                 shadow.append(viewer);
                 this._viewer = viewer;
+                this._currentState = EmbedState.QRCode;
                 return;
             }
             return reject(new Error("PlattarEmbed.startQRCode() - minimum required attributes not set, use scene-id or product-id as a minimum"));
         });
     }
+    /**
+     * This is called by the observer if any of the embed attributes have changed
+     * based on the state of the embed, we update the internal structure accordingly
+     */
+    _OnAttributesUpdated() {
+        // nothing to update in these scenarios
+        if (this._currentState === EmbedState.None ||
+            this._currentState === EmbedState.ProductAR ||
+            this._currentState === EmbedState.ConfiguratorViewer) {
+            return;
+        }
+        // re-render the QR Code when attributes have changed
+        if (this._currentState === EmbedState.QRCode) {
+            this.startQRCode(this._qrCodeOptions);
+            return;
+        }
+        // use the messenger function to change variation when attributes have changed
+        if (this._currentState === EmbedState.SceneViewer) {
+            const viewer = this.viewer;
+            if (viewer) {
+                viewer.messenger.selectVariation(this._productID, this._variationID);
+            }
+            return;
+        }
+        if (this._currentState === EmbedState.ProductViewer) {
+            const viewer = this.viewer;
+            if (viewer) {
+                viewer.messenger.selectVariation(this._variationID);
+            }
+            return;
+        }
+    }
 }
 exports.default = PlattarEmbed;

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export { ConfiguratorAR } from "./ar/configurator-ar";
 export { ProductAR } from "./ar/product-ar";
 export { SceneAR } from "./ar/scene-ar";
 export { ModelAR } from "./ar/model-ar";
+export { RawAR } from "./ar/raw-ar";
 export { Util } from "./util/util";

package/dist/index.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Util = exports.ModelAR = exports.SceneAR = exports.ProductAR = exports.ConfiguratorAR = exports.version = exports.PlattarQRCode = exports.PlattarWeb = void 0;
+exports.Util = exports.RawAR = exports.ModelAR = exports.SceneAR = exports.ProductAR = exports.ConfiguratorAR = exports.version = exports.PlattarQRCode = exports.PlattarWeb = void 0;
 exports.PlattarWeb = __importStar(require("@plattar/plattar-web"));
 exports.PlattarQRCode = __importStar(require("@plattar/plattar-qrcode"));
 exports.version = __importStar(require("./version"));
@@ -34,6 +34,8 @@ var scene_ar_1 = require("./ar/scene-ar");
 Object.defineProperty(exports, "SceneAR", { enumerable: true, get: function () { return scene_ar_1.SceneAR; } });
 var model_ar_1 = require("./ar/model-ar");
 Object.defineProperty(exports, "ModelAR", { enumerable: true, get: function () { return model_ar_1.ModelAR; } });
+var raw_ar_1 = require("./ar/raw-ar");
+Object.defineProperty(exports, "RawAR", { enumerable: true, get: function () { return raw_ar_1.RawAR; } });
 var util_1 = require("./util/util");
 Object.defineProperty(exports, "Util", { enumerable: true, get: function () { return util_1.Util; } });
 const plattar_embed_1 = __importDefault(require("./embed/plattar-embed"));

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "1.121.1";
+declare const _default: "1.122.4";
 export default _default;

package/dist/version.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = "1.121.1";
+exports.default = "1.122.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plattar/plattar-ar-adapter",
-  "version": "1.121.1",
+  "version": "1.122.4",
   "description": "Plattar AR Adapter for interfacing with Google & Apple WebAR",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -40,14 +40,15 @@
     "@plattar/plattar-analytics": "^1.117.2",
     "@plattar/plattar-api": "^1.120.1",
     "@plattar/plattar-qrcode": "1.120.3",
-    "@plattar/plattar-web": "^1.117.1"
+    "@plattar/plattar-services": "^1.120.1",
+    "@plattar/plattar-web": "^1.122.3"
   },
   "devDependencies": {
-    "@babel/cli": "^7.16.0",
-    "@babel/core": "^7.16.0",
-    "@babel/preset-env": "^7.16.4",
+    "@babel/cli": "^7.16.8",
+    "@babel/core": "^7.16.12",
+    "@babel/preset-env": "^7.16.11",
     "browserify": "^17.0.0",
-    "typescript": "^4.5.2",
+    "typescript": "^4.5.5",
     "uglify-es": "^3.3.9"
   },
   "publishConfig": {