botframework-webchat-fluent-theme 4.17.0-main.20240411.647b269 → 4.17.0-main.20240416.4ff01ae

package/dist/botframework-webchat-fluent-theme.development.js

@@ -0,0 +1,2384 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // src/external.umd/botframework-webchat-component.ts
+  var require_botframework_webchat_component = __commonJS({
+    "src/external.umd/botframework-webchat-component.ts"(exports, module) {
+      module.exports = {
+        Components: globalThis.WebChat.Components,
+        hooks: globalThis.WebChat.hooks
+      };
+    }
+  });
+
+  // src/external.umd/react.ts
+  var require_react = __commonJS({
+    "src/external.umd/react.ts"(exports, module) {
+      module.exports = globalThis.React;
+    }
+  });
+
+  // node_modules/core-js-pure/internals/global.js
+  var require_global = __commonJS({
+    "node_modules/core-js-pure/internals/global.js"(exports, module) {
+      "use strict";
+      var check = function(it) {
+        return it && it.Math === Math && it;
+      };
+      module.exports = // eslint-disable-next-line es/no-global-this -- safe
+      check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || // eslint-disable-next-line no-restricted-globals -- safe
+      check(typeof self == "object" && self) || check(typeof global == "object" && global) || check(typeof exports == "object" && exports) || // eslint-disable-next-line no-new-func -- fallback
+      /* @__PURE__ */ function() {
+        return this;
+      }() || Function("return this")();
+    }
+  });
+
+  // node_modules/core-js-pure/internals/fails.js
+  var require_fails = __commonJS({
+    "node_modules/core-js-pure/internals/fails.js"(exports, module) {
+      "use strict";
+      module.exports = function(exec) {
+        try {
+          return !!exec();
+        } catch (error) {
+          return true;
+        }
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/function-bind-native.js
+  var require_function_bind_native = __commonJS({
+    "node_modules/core-js-pure/internals/function-bind-native.js"(exports, module) {
+      "use strict";
+      var fails = require_fails();
+      module.exports = !fails(function() {
+        var test = (function() {
+        }).bind();
+        return typeof test != "function" || test.hasOwnProperty("prototype");
+      });
+    }
+  });
+
+  // node_modules/core-js-pure/internals/function-apply.js
+  var require_function_apply = __commonJS({
+    "node_modules/core-js-pure/internals/function-apply.js"(exports, module) {
+      "use strict";
+      var NATIVE_BIND = require_function_bind_native();
+      var FunctionPrototype = Function.prototype;
+      var apply = FunctionPrototype.apply;
+      var call = FunctionPrototype.call;
+      module.exports = typeof Reflect == "object" && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function() {
+        return call.apply(apply, arguments);
+      });
+    }
+  });
+
+  // node_modules/core-js-pure/internals/function-uncurry-this.js
+  var require_function_uncurry_this = __commonJS({
+    "node_modules/core-js-pure/internals/function-uncurry-this.js"(exports, module) {
+      "use strict";
+      var NATIVE_BIND = require_function_bind_native();
+      var FunctionPrototype = Function.prototype;
+      var call = FunctionPrototype.call;
+      var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
+      module.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn) {
+        return function() {
+          return call.apply(fn, arguments);
+        };
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/classof-raw.js
+  var require_classof_raw = __commonJS({
+    "node_modules/core-js-pure/internals/classof-raw.js"(exports, module) {
+      "use strict";
+      var uncurryThis = require_function_uncurry_this();
+      var toString = uncurryThis({}.toString);
+      var stringSlice = uncurryThis("".slice);
+      module.exports = function(it) {
+        return stringSlice(toString(it), 8, -1);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/function-uncurry-this-clause.js
+  var require_function_uncurry_this_clause = __commonJS({
+    "node_modules/core-js-pure/internals/function-uncurry-this-clause.js"(exports, module) {
+      "use strict";
+      var classofRaw = require_classof_raw();
+      var uncurryThis = require_function_uncurry_this();
+      module.exports = function(fn) {
+        if (classofRaw(fn) === "Function")
+          return uncurryThis(fn);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/is-callable.js
+  var require_is_callable = __commonJS({
+    "node_modules/core-js-pure/internals/is-callable.js"(exports, module) {
+      "use strict";
+      var documentAll = typeof document == "object" && document.all;
+      module.exports = typeof documentAll == "undefined" && documentAll !== void 0 ? function(argument) {
+        return typeof argument == "function" || argument === documentAll;
+      } : function(argument) {
+        return typeof argument == "function";
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/descriptors.js
+  var require_descriptors = __commonJS({
+    "node_modules/core-js-pure/internals/descriptors.js"(exports, module) {
+      "use strict";
+      var fails = require_fails();
+      module.exports = !fails(function() {
+        return Object.defineProperty({}, 1, { get: function() {
+          return 7;
+        } })[1] !== 7;
+      });
+    }
+  });
+
+  // node_modules/core-js-pure/internals/function-call.js
+  var require_function_call = __commonJS({
+    "node_modules/core-js-pure/internals/function-call.js"(exports, module) {
+      "use strict";
+      var NATIVE_BIND = require_function_bind_native();
+      var call = Function.prototype.call;
+      module.exports = NATIVE_BIND ? call.bind(call) : function() {
+        return call.apply(call, arguments);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/object-property-is-enumerable.js
+  var require_object_property_is_enumerable = __commonJS({
+    "node_modules/core-js-pure/internals/object-property-is-enumerable.js"(exports) {
+      "use strict";
+      var $propertyIsEnumerable = {}.propertyIsEnumerable;
+      var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+      var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+      exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+        var descriptor = getOwnPropertyDescriptor(this, V);
+        return !!descriptor && descriptor.enumerable;
+      } : $propertyIsEnumerable;
+    }
+  });
+
+  // node_modules/core-js-pure/internals/create-property-descriptor.js
+  var require_create_property_descriptor = __commonJS({
+    "node_modules/core-js-pure/internals/create-property-descriptor.js"(exports, module) {
+      "use strict";
+      module.exports = function(bitmap, value) {
+        return {
+          enumerable: !(bitmap & 1),
+          configurable: !(bitmap & 2),
+          writable: !(bitmap & 4),
+          value
+        };
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/indexed-object.js
+  var require_indexed_object = __commonJS({
+    "node_modules/core-js-pure/internals/indexed-object.js"(exports, module) {
+      "use strict";
+      var uncurryThis = require_function_uncurry_this();
+      var fails = require_fails();
+      var classof = require_classof_raw();
+      var $Object = Object;
+      var split = uncurryThis("".split);
+      module.exports = fails(function() {
+        return !$Object("z").propertyIsEnumerable(0);
+      }) ? function(it) {
+        return classof(it) === "String" ? split(it, "") : $Object(it);
+      } : $Object;
+    }
+  });
+
+  // node_modules/core-js-pure/internals/is-null-or-undefined.js
+  var require_is_null_or_undefined = __commonJS({
+    "node_modules/core-js-pure/internals/is-null-or-undefined.js"(exports, module) {
+      "use strict";
+      module.exports = function(it) {
+        return it === null || it === void 0;
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/require-object-coercible.js
+  var require_require_object_coercible = __commonJS({
+    "node_modules/core-js-pure/internals/require-object-coercible.js"(exports, module) {
+      "use strict";
+      var isNullOrUndefined = require_is_null_or_undefined();
+      var $TypeError = TypeError;
+      module.exports = function(it) {
+        if (isNullOrUndefined(it))
+          throw new $TypeError("Can't call method on " + it);
+        return it;
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/to-indexed-object.js
+  var require_to_indexed_object = __commonJS({
+    "node_modules/core-js-pure/internals/to-indexed-object.js"(exports, module) {
+      "use strict";
+      var IndexedObject = require_indexed_object();
+      var requireObjectCoercible = require_require_object_coercible();
+      module.exports = function(it) {
+        return IndexedObject(requireObjectCoercible(it));
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/is-object.js
+  var require_is_object = __commonJS({
+    "node_modules/core-js-pure/internals/is-object.js"(exports, module) {
+      "use strict";
+      var isCallable = require_is_callable();
+      module.exports = function(it) {
+        return typeof it == "object" ? it !== null : isCallable(it);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/path.js
+  var require_path = __commonJS({
+    "node_modules/core-js-pure/internals/path.js"(exports, module) {
+      "use strict";
+      module.exports = {};
+    }
+  });
+
+  // node_modules/core-js-pure/internals/get-built-in.js
+  var require_get_built_in = __commonJS({
+    "node_modules/core-js-pure/internals/get-built-in.js"(exports, module) {
+      "use strict";
+      var path = require_path();
+      var global2 = require_global();
+      var isCallable = require_is_callable();
+      var aFunction = function(variable) {
+        return isCallable(variable) ? variable : void 0;
+      };
+      module.exports = function(namespace, method) {
+        return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global2[namespace]) : path[namespace] && path[namespace][method] || global2[namespace] && global2[namespace][method];
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/object-is-prototype-of.js
+  var require_object_is_prototype_of = __commonJS({
+    "node_modules/core-js-pure/internals/object-is-prototype-of.js"(exports, module) {
+      "use strict";
+      var uncurryThis = require_function_uncurry_this();
+      module.exports = uncurryThis({}.isPrototypeOf);
+    }
+  });
+
+  // node_modules/core-js-pure/internals/engine-user-agent.js
+  var require_engine_user_agent = __commonJS({
+    "node_modules/core-js-pure/internals/engine-user-agent.js"(exports, module) {
+      "use strict";
+      module.exports = typeof navigator != "undefined" && String(navigator.userAgent) || "";
+    }
+  });
+
+  // node_modules/core-js-pure/internals/engine-v8-version.js
+  var require_engine_v8_version = __commonJS({
+    "node_modules/core-js-pure/internals/engine-v8-version.js"(exports, module) {
+      "use strict";
+      var global2 = require_global();
+      var userAgent = require_engine_user_agent();
+      var process = global2.process;
+      var Deno = global2.Deno;
+      var versions = process && process.versions || Deno && Deno.version;
+      var v8 = versions && versions.v8;
+      var match;
+      var version;
+      if (v8) {
+        match = v8.split(".");
+        version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+      }
+      if (!version && userAgent) {
+        match = userAgent.match(/Edge\/(\d+)/);
+        if (!match || match[1] >= 74) {
+          match = userAgent.match(/Chrome\/(\d+)/);
+          if (match)
+            version = +match[1];
+        }
+      }
+      module.exports = version;
+    }
+  });
+
+  // node_modules/core-js-pure/internals/symbol-constructor-detection.js
+  var require_symbol_constructor_detection = __commonJS({
+    "node_modules/core-js-pure/internals/symbol-constructor-detection.js"(exports, module) {
+      "use strict";
+      var V8_VERSION = require_engine_v8_version();
+      var fails = require_fails();
+      var global2 = require_global();
+      var $String = global2.String;
+      module.exports = !!Object.getOwnPropertySymbols && !fails(function() {
+        var symbol = Symbol("symbol detection");
+        return !$String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+        !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+      });
+    }
+  });
+
+  // node_modules/core-js-pure/internals/use-symbol-as-uid.js
+  var require_use_symbol_as_uid = __commonJS({
+    "node_modules/core-js-pure/internals/use-symbol-as-uid.js"(exports, module) {
+      "use strict";
+      var NATIVE_SYMBOL = require_symbol_constructor_detection();
+      module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol";
+    }
+  });
+
+  // node_modules/core-js-pure/internals/is-symbol.js
+  var require_is_symbol = __commonJS({
+    "node_modules/core-js-pure/internals/is-symbol.js"(exports, module) {
+      "use strict";
+      var getBuiltIn = require_get_built_in();
+      var isCallable = require_is_callable();
+      var isPrototypeOf = require_object_is_prototype_of();
+      var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
+      var $Object = Object;
+      module.exports = USE_SYMBOL_AS_UID ? function(it) {
+        return typeof it == "symbol";
+      } : function(it) {
+        var $Symbol = getBuiltIn("Symbol");
+        return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/try-to-string.js
+  var require_try_to_string = __commonJS({
+    "node_modules/core-js-pure/internals/try-to-string.js"(exports, module) {
+      "use strict";
+      var $String = String;
+      module.exports = function(argument) {
+        try {
+          return $String(argument);
+        } catch (error) {
+          return "Object";
+        }
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/a-callable.js
+  var require_a_callable = __commonJS({
+    "node_modules/core-js-pure/internals/a-callable.js"(exports, module) {
+      "use strict";
+      var isCallable = require_is_callable();
+      var tryToString = require_try_to_string();
+      var $TypeError = TypeError;
+      module.exports = function(argument) {
+        if (isCallable(argument))
+          return argument;
+        throw new $TypeError(tryToString(argument) + " is not a function");
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/get-method.js
+  var require_get_method = __commonJS({
+    "node_modules/core-js-pure/internals/get-method.js"(exports, module) {
+      "use strict";
+      var aCallable = require_a_callable();
+      var isNullOrUndefined = require_is_null_or_undefined();
+      module.exports = function(V, P) {
+        var func = V[P];
+        return isNullOrUndefined(func) ? void 0 : aCallable(func);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/ordinary-to-primitive.js
+  var require_ordinary_to_primitive = __commonJS({
+    "node_modules/core-js-pure/internals/ordinary-to-primitive.js"(exports, module) {
+      "use strict";
+      var call = require_function_call();
+      var isCallable = require_is_callable();
+      var isObject = require_is_object();
+      var $TypeError = TypeError;
+      module.exports = function(input, pref) {
+        var fn, val;
+        if (pref === "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input)))
+          return val;
+        if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input)))
+          return val;
+        if (pref !== "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input)))
+          return val;
+        throw new $TypeError("Can't convert object to primitive value");
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/is-pure.js
+  var require_is_pure = __commonJS({
+    "node_modules/core-js-pure/internals/is-pure.js"(exports, module) {
+      "use strict";
+      module.exports = true;
+    }
+  });
+
+  // node_modules/core-js-pure/internals/define-global-property.js
+  var require_define_global_property = __commonJS({
+    "node_modules/core-js-pure/internals/define-global-property.js"(exports, module) {
+      "use strict";
+      var global2 = require_global();
+      var defineProperty = Object.defineProperty;
+      module.exports = function(key, value) {
+        try {
+          defineProperty(global2, key, { value, configurable: true, writable: true });
+        } catch (error) {
+          global2[key] = value;
+        }
+        return value;
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/shared-store.js
+  var require_shared_store = __commonJS({
+    "node_modules/core-js-pure/internals/shared-store.js"(exports, module) {
+      "use strict";
+      var IS_PURE = require_is_pure();
+      var globalThis2 = require_global();
+      var defineGlobalProperty = require_define_global_property();
+      var SHARED = "__core-js_shared__";
+      var store = module.exports = globalThis2[SHARED] || defineGlobalProperty(SHARED, {});
+      (store.versions || (store.versions = [])).push({
+        version: "3.36.1",
+        mode: IS_PURE ? "pure" : "global",
+        copyright: "\xA9 2014-2024 Denis Pushkarev (zloirock.ru)",
+        license: "https://github.com/zloirock/core-js/blob/v3.36.1/LICENSE",
+        source: "https://github.com/zloirock/core-js"
+      });
+    }
+  });
+
+  // node_modules/core-js-pure/internals/shared.js
+  var require_shared = __commonJS({
+    "node_modules/core-js-pure/internals/shared.js"(exports, module) {
+      "use strict";
+      var store = require_shared_store();
+      module.exports = function(key, value) {
+        return store[key] || (store[key] = value || {});
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/to-object.js
+  var require_to_object = __commonJS({
+    "node_modules/core-js-pure/internals/to-object.js"(exports, module) {
+      "use strict";
+      var requireObjectCoercible = require_require_object_coercible();
+      var $Object = Object;
+      module.exports = function(argument) {
+        return $Object(requireObjectCoercible(argument));
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/has-own-property.js
+  var require_has_own_property = __commonJS({
+    "node_modules/core-js-pure/internals/has-own-property.js"(exports, module) {
+      "use strict";
+      var uncurryThis = require_function_uncurry_this();
+      var toObject = require_to_object();
+      var hasOwnProperty = uncurryThis({}.hasOwnProperty);
+      module.exports = Object.hasOwn || function hasOwn(it, key) {
+        return hasOwnProperty(toObject(it), key);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/uid.js
+  var require_uid = __commonJS({
+    "node_modules/core-js-pure/internals/uid.js"(exports, module) {
+      "use strict";
+      var uncurryThis = require_function_uncurry_this();
+      var id = 0;
+      var postfix = Math.random();
+      var toString = uncurryThis(1 .toString);
+      module.exports = function(key) {
+        return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString(++id + postfix, 36);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/well-known-symbol.js
+  var require_well_known_symbol = __commonJS({
+    "node_modules/core-js-pure/internals/well-known-symbol.js"(exports, module) {
+      "use strict";
+      var global2 = require_global();
+      var shared = require_shared();
+      var hasOwn = require_has_own_property();
+      var uid = require_uid();
+      var NATIVE_SYMBOL = require_symbol_constructor_detection();
+      var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
+      var Symbol2 = global2.Symbol;
+      var WellKnownSymbolsStore = shared("wks");
+      var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2["for"] || Symbol2 : Symbol2 && Symbol2.withoutSetter || uid;
+      module.exports = function(name) {
+        if (!hasOwn(WellKnownSymbolsStore, name)) {
+          WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol2, name) ? Symbol2[name] : createWellKnownSymbol("Symbol." + name);
+        }
+        return WellKnownSymbolsStore[name];
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/to-primitive.js
+  var require_to_primitive = __commonJS({
+    "node_modules/core-js-pure/internals/to-primitive.js"(exports, module) {
+      "use strict";
+      var call = require_function_call();
+      var isObject = require_is_object();
+      var isSymbol = require_is_symbol();
+      var getMethod = require_get_method();
+      var ordinaryToPrimitive = require_ordinary_to_primitive();
+      var wellKnownSymbol = require_well_known_symbol();
+      var $TypeError = TypeError;
+      var TO_PRIMITIVE = wellKnownSymbol("toPrimitive");
+      module.exports = function(input, pref) {
+        if (!isObject(input) || isSymbol(input))
+          return input;
+        var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+        var result;
+        if (exoticToPrim) {
+          if (pref === void 0)
+            pref = "default";
+          result = call(exoticToPrim, input, pref);
+          if (!isObject(result) || isSymbol(result))
+            return result;
+          throw new $TypeError("Can't convert object to primitive value");
+        }
+        if (pref === void 0)
+          pref = "number";
+        return ordinaryToPrimitive(input, pref);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/to-property-key.js
+  var require_to_property_key = __commonJS({
+    "node_modules/core-js-pure/internals/to-property-key.js"(exports, module) {
+      "use strict";
+      var toPrimitive = require_to_primitive();
+      var isSymbol = require_is_symbol();
+      module.exports = function(argument) {
+        var key = toPrimitive(argument, "string");
+        return isSymbol(key) ? key : key + "";
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/document-create-element.js
+  var require_document_create_element = __commonJS({
+    "node_modules/core-js-pure/internals/document-create-element.js"(exports, module) {
+      "use strict";
+      var global2 = require_global();
+      var isObject = require_is_object();
+      var document2 = global2.document;
+      var EXISTS = isObject(document2) && isObject(document2.createElement);
+      module.exports = function(it) {
+        return EXISTS ? document2.createElement(it) : {};
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/ie8-dom-define.js
+  var require_ie8_dom_define = __commonJS({
+    "node_modules/core-js-pure/internals/ie8-dom-define.js"(exports, module) {
+      "use strict";
+      var DESCRIPTORS = require_descriptors();
+      var fails = require_fails();
+      var createElement = require_document_create_element();
+      module.exports = !DESCRIPTORS && !fails(function() {
+        return Object.defineProperty(createElement("div"), "a", {
+          get: function() {
+            return 7;
+          }
+        }).a !== 7;
+      });
+    }
+  });
+
+  // node_modules/core-js-pure/internals/object-get-own-property-descriptor.js
+  var require_object_get_own_property_descriptor = __commonJS({
+    "node_modules/core-js-pure/internals/object-get-own-property-descriptor.js"(exports) {
+      "use strict";
+      var DESCRIPTORS = require_descriptors();
+      var call = require_function_call();
+      var propertyIsEnumerableModule = require_object_property_is_enumerable();
+      var createPropertyDescriptor = require_create_property_descriptor();
+      var toIndexedObject = require_to_indexed_object();
+      var toPropertyKey = require_to_property_key();
+      var hasOwn = require_has_own_property();
+      var IE8_DOM_DEFINE = require_ie8_dom_define();
+      var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+      exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+        O = toIndexedObject(O);
+        P = toPropertyKey(P);
+        if (IE8_DOM_DEFINE)
+          try {
+            return $getOwnPropertyDescriptor(O, P);
+          } catch (error) {
+          }
+        if (hasOwn(O, P))
+          return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/is-forced.js
+  var require_is_forced = __commonJS({
+    "node_modules/core-js-pure/internals/is-forced.js"(exports, module) {
+      "use strict";
+      var fails = require_fails();
+      var isCallable = require_is_callable();
+      var replacement = /#|\.prototype\./;
+      var isForced = function(feature, detection) {
+        var value = data[normalize(feature)];
+        return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
+      };
+      var normalize = isForced.normalize = function(string) {
+        return String(string).replace(replacement, ".").toLowerCase();
+      };
+      var data = isForced.data = {};
+      var NATIVE = isForced.NATIVE = "N";
+      var POLYFILL = isForced.POLYFILL = "P";
+      module.exports = isForced;
+    }
+  });
+
+  // node_modules/core-js-pure/internals/function-bind-context.js
+  var require_function_bind_context = __commonJS({
+    "node_modules/core-js-pure/internals/function-bind-context.js"(exports, module) {
+      "use strict";
+      var uncurryThis = require_function_uncurry_this_clause();
+      var aCallable = require_a_callable();
+      var NATIVE_BIND = require_function_bind_native();
+      var bind = uncurryThis(uncurryThis.bind);
+      module.exports = function(fn, that) {
+        aCallable(fn);
+        return that === void 0 ? fn : NATIVE_BIND ? bind(fn, that) : function() {
+          return fn.apply(that, arguments);
+        };
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/v8-prototype-define-bug.js
+  var require_v8_prototype_define_bug = __commonJS({
+    "node_modules/core-js-pure/internals/v8-prototype-define-bug.js"(exports, module) {
+      "use strict";
+      var DESCRIPTORS = require_descriptors();
+      var fails = require_fails();
+      module.exports = DESCRIPTORS && fails(function() {
+        return Object.defineProperty(function() {
+        }, "prototype", {
+          value: 42,
+          writable: false
+        }).prototype !== 42;
+      });
+    }
+  });
+
+  // node_modules/core-js-pure/internals/an-object.js
+  var require_an_object = __commonJS({
+    "node_modules/core-js-pure/internals/an-object.js"(exports, module) {
+      "use strict";
+      var isObject = require_is_object();
+      var $String = String;
+      var $TypeError = TypeError;
+      module.exports = function(argument) {
+        if (isObject(argument))
+          return argument;
+        throw new $TypeError($String(argument) + " is not an object");
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/object-define-property.js
+  var require_object_define_property = __commonJS({
+    "node_modules/core-js-pure/internals/object-define-property.js"(exports) {
+      "use strict";
+      var DESCRIPTORS = require_descriptors();
+      var IE8_DOM_DEFINE = require_ie8_dom_define();
+      var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
+      var anObject = require_an_object();
+      var toPropertyKey = require_to_property_key();
+      var $TypeError = TypeError;
+      var $defineProperty = Object.defineProperty;
+      var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+      var ENUMERABLE = "enumerable";
+      var CONFIGURABLE = "configurable";
+      var WRITABLE = "writable";
+      exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+        anObject(O);
+        P = toPropertyKey(P);
+        anObject(Attributes);
+        if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+          var current = $getOwnPropertyDescriptor(O, P);
+          if (current && current[WRITABLE]) {
+            O[P] = Attributes.value;
+            Attributes = {
+              configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+              enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+              writable: false
+            };
+          }
+        }
+        return $defineProperty(O, P, Attributes);
+      } : $defineProperty : function defineProperty(O, P, Attributes) {
+        anObject(O);
+        P = toPropertyKey(P);
+        anObject(Attributes);
+        if (IE8_DOM_DEFINE)
+          try {
+            return $defineProperty(O, P, Attributes);
+          } catch (error) {
+          }
+        if ("get" in Attributes || "set" in Attributes)
+          throw new $TypeError("Accessors not supported");
+        if ("value" in Attributes)
+          O[P] = Attributes.value;
+        return O;
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/create-non-enumerable-property.js
+  var require_create_non_enumerable_property = __commonJS({
+    "node_modules/core-js-pure/internals/create-non-enumerable-property.js"(exports, module) {
+      "use strict";
+      var DESCRIPTORS = require_descriptors();
+      var definePropertyModule = require_object_define_property();
+      var createPropertyDescriptor = require_create_property_descriptor();
+      module.exports = DESCRIPTORS ? function(object, key, value) {
+        return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+      } : function(object, key, value) {
+        object[key] = value;
+        return object;
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/export.js
+  var require_export = __commonJS({
+    "node_modules/core-js-pure/internals/export.js"(exports, module) {
+      "use strict";
+      var global2 = require_global();
+      var apply = require_function_apply();
+      var uncurryThis = require_function_uncurry_this_clause();
+      var isCallable = require_is_callable();
+      var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f;
+      var isForced = require_is_forced();
+      var path = require_path();
+      var bind = require_function_bind_context();
+      var createNonEnumerableProperty = require_create_non_enumerable_property();
+      var hasOwn = require_has_own_property();
+      require_shared_store();
+      var wrapConstructor = function(NativeConstructor) {
+        var Wrapper = function(a, b, c) {
+          if (this instanceof Wrapper) {
+            switch (arguments.length) {
+              case 0:
+                return new NativeConstructor();
+              case 1:
+                return new NativeConstructor(a);
+              case 2:
+                return new NativeConstructor(a, b);
+            }
+            return new NativeConstructor(a, b, c);
+          }
+          return apply(NativeConstructor, this, arguments);
+        };
+        Wrapper.prototype = NativeConstructor.prototype;
+        return Wrapper;
+      };
+      module.exports = function(options, source) {
+        var TARGET = options.target;
+        var GLOBAL = options.global;
+        var STATIC = options.stat;
+        var PROTO = options.proto;
+        var nativeSource = GLOBAL ? global2 : STATIC ? global2[TARGET] : global2[TARGET] && global2[TARGET].prototype;
+        var target = GLOBAL ? path : path[TARGET] || createNonEnumerableProperty(path, TARGET, {})[TARGET];
+        var targetPrototype = target.prototype;
+        var FORCED, USE_NATIVE, VIRTUAL_PROTOTYPE;
+        var key, sourceProperty, targetProperty, nativeProperty, resultProperty, descriptor;
+        for (key in source) {
+          FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
+          USE_NATIVE = !FORCED && nativeSource && hasOwn(nativeSource, key);
+          targetProperty = target[key];
+          if (USE_NATIVE)
+            if (options.dontCallGetSet) {
+              descriptor = getOwnPropertyDescriptor(nativeSource, key);
+              nativeProperty = descriptor && descriptor.value;
+            } else
+              nativeProperty = nativeSource[key];
+          sourceProperty = USE_NATIVE && nativeProperty ? nativeProperty : source[key];
+          if (!FORCED && !PROTO && typeof targetProperty == typeof sourceProperty)
+            continue;
+          if (options.bind && USE_NATIVE)
+            resultProperty = bind(sourceProperty, global2);
+          else if (options.wrap && USE_NATIVE)
+            resultProperty = wrapConstructor(sourceProperty);
+          else if (PROTO && isCallable(sourceProperty))
+            resultProperty = uncurryThis(sourceProperty);
+          else
+            resultProperty = sourceProperty;
+          if (options.sham || sourceProperty && sourceProperty.sham || targetProperty && targetProperty.sham) {
+            createNonEnumerableProperty(resultProperty, "sham", true);
+          }
+          createNonEnumerableProperty(target, key, resultProperty);
+          if (PROTO) {
+            VIRTUAL_PROTOTYPE = TARGET + "Prototype";
+            if (!hasOwn(path, VIRTUAL_PROTOTYPE)) {
+              createNonEnumerableProperty(path, VIRTUAL_PROTOTYPE, {});
+            }
+            createNonEnumerableProperty(path[VIRTUAL_PROTOTYPE], key, sourceProperty);
+            if (options.real && targetPrototype && (FORCED || !targetPrototype[key])) {
+              createNonEnumerableProperty(targetPrototype, key, sourceProperty);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/math-trunc.js
+  var require_math_trunc = __commonJS({
+    "node_modules/core-js-pure/internals/math-trunc.js"(exports, module) {
+      "use strict";
+      var ceil = Math.ceil;
+      var floor = Math.floor;
+      module.exports = Math.trunc || function trunc(x) {
+        var n = +x;
+        return (n > 0 ? floor : ceil)(n);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/to-integer-or-infinity.js
+  var require_to_integer_or_infinity = __commonJS({
+    "node_modules/core-js-pure/internals/to-integer-or-infinity.js"(exports, module) {
+      "use strict";
+      var trunc = require_math_trunc();
+      module.exports = function(argument) {
+        var number = +argument;
+        return number !== number || number === 0 ? 0 : trunc(number);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/to-absolute-index.js
+  var require_to_absolute_index = __commonJS({
+    "node_modules/core-js-pure/internals/to-absolute-index.js"(exports, module) {
+      "use strict";
+      var toIntegerOrInfinity = require_to_integer_or_infinity();
+      var max = Math.max;
+      var min = Math.min;
+      module.exports = function(index, length) {
+        var integer = toIntegerOrInfinity(index);
+        return integer < 0 ? max(integer + length, 0) : min(integer, length);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/to-length.js
+  var require_to_length = __commonJS({
+    "node_modules/core-js-pure/internals/to-length.js"(exports, module) {
+      "use strict";
+      var toIntegerOrInfinity = require_to_integer_or_infinity();
+      var min = Math.min;
+      module.exports = function(argument) {
+        var len = toIntegerOrInfinity(argument);
+        return len > 0 ? min(len, 9007199254740991) : 0;
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/length-of-array-like.js
+  var require_length_of_array_like = __commonJS({
+    "node_modules/core-js-pure/internals/length-of-array-like.js"(exports, module) {
+      "use strict";
+      var toLength = require_to_length();
+      module.exports = function(obj) {
+        return toLength(obj.length);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/array-includes.js
+  var require_array_includes = __commonJS({
+    "node_modules/core-js-pure/internals/array-includes.js"(exports, module) {
+      "use strict";
+      var toIndexedObject = require_to_indexed_object();
+      var toAbsoluteIndex = require_to_absolute_index();
+      var lengthOfArrayLike = require_length_of_array_like();
+      var createMethod = function(IS_INCLUDES) {
+        return function($this, el, fromIndex) {
+          var O = toIndexedObject($this);
+          var length = lengthOfArrayLike(O);
+          if (length === 0)
+            return !IS_INCLUDES && -1;
+          var index = toAbsoluteIndex(fromIndex, length);
+          var value;
+          if (IS_INCLUDES && el !== el)
+            while (length > index) {
+              value = O[index++];
+              if (value !== value)
+                return true;
+            }
+          else
+            for (; length > index; index++) {
+              if ((IS_INCLUDES || index in O) && O[index] === el)
+                return IS_INCLUDES || index || 0;
+            }
+          return !IS_INCLUDES && -1;
+        };
+      };
+      module.exports = {
+        // `Array.prototype.includes` method
+        // https://tc39.es/ecma262/#sec-array.prototype.includes
+        includes: createMethod(true),
+        // `Array.prototype.indexOf` method
+        // https://tc39.es/ecma262/#sec-array.prototype.indexof
+        indexOf: createMethod(false)
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/hidden-keys.js
+  var require_hidden_keys = __commonJS({
+    "node_modules/core-js-pure/internals/hidden-keys.js"(exports, module) {
+      "use strict";
+      module.exports = {};
+    }
+  });
+
+  // node_modules/core-js-pure/internals/object-keys-internal.js
+  var require_object_keys_internal = __commonJS({
+    "node_modules/core-js-pure/internals/object-keys-internal.js"(exports, module) {
+      "use strict";
+      var uncurryThis = require_function_uncurry_this();
+      var hasOwn = require_has_own_property();
+      var toIndexedObject = require_to_indexed_object();
+      var indexOf = require_array_includes().indexOf;
+      var hiddenKeys = require_hidden_keys();
+      var push = uncurryThis([].push);
+      module.exports = function(object, names) {
+        var O = toIndexedObject(object);
+        var i = 0;
+        var result = [];
+        var key;
+        for (key in O)
+          !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
+        while (names.length > i)
+          if (hasOwn(O, key = names[i++])) {
+            ~indexOf(result, key) || push(result, key);
+          }
+        return result;
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/enum-bug-keys.js
+  var require_enum_bug_keys = __commonJS({
+    "node_modules/core-js-pure/internals/enum-bug-keys.js"(exports, module) {
+      "use strict";
+      module.exports = [
+        "constructor",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable",
+        "toLocaleString",
+        "toString",
+        "valueOf"
+      ];
+    }
+  });
+
+  // node_modules/core-js-pure/internals/object-keys.js
+  var require_object_keys = __commonJS({
+    "node_modules/core-js-pure/internals/object-keys.js"(exports, module) {
+      "use strict";
+      var internalObjectKeys = require_object_keys_internal();
+      var enumBugKeys = require_enum_bug_keys();
+      module.exports = Object.keys || function keys(O) {
+        return internalObjectKeys(O, enumBugKeys);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/object-define-properties.js
+  var require_object_define_properties = __commonJS({
+    "node_modules/core-js-pure/internals/object-define-properties.js"(exports) {
+      "use strict";
+      var DESCRIPTORS = require_descriptors();
+      var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
+      var definePropertyModule = require_object_define_property();
+      var anObject = require_an_object();
+      var toIndexedObject = require_to_indexed_object();
+      var objectKeys = require_object_keys();
+      exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
+        anObject(O);
+        var props = toIndexedObject(Properties);
+        var keys = objectKeys(Properties);
+        var length = keys.length;
+        var index = 0;
+        var key;
+        while (length > index)
+          definePropertyModule.f(O, key = keys[index++], props[key]);
+        return O;
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/html.js
+  var require_html = __commonJS({
+    "node_modules/core-js-pure/internals/html.js"(exports, module) {
+      "use strict";
+      var getBuiltIn = require_get_built_in();
+      module.exports = getBuiltIn("document", "documentElement");
+    }
+  });
+
+  // node_modules/core-js-pure/internals/shared-key.js
+  var require_shared_key = __commonJS({
+    "node_modules/core-js-pure/internals/shared-key.js"(exports, module) {
+      "use strict";
+      var shared = require_shared();
+      var uid = require_uid();
+      var keys = shared("keys");
+      module.exports = function(key) {
+        return keys[key] || (keys[key] = uid(key));
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/internals/object-create.js
+  var require_object_create = __commonJS({
+    "node_modules/core-js-pure/internals/object-create.js"(exports, module) {
+      "use strict";
+      var anObject = require_an_object();
+      var definePropertiesModule = require_object_define_properties();
+      var enumBugKeys = require_enum_bug_keys();
+      var hiddenKeys = require_hidden_keys();
+      var html = require_html();
+      var documentCreateElement = require_document_create_element();
+      var sharedKey = require_shared_key();
+      var GT = ">";
+      var LT = "<";
+      var PROTOTYPE = "prototype";
+      var SCRIPT = "script";
+      var IE_PROTO = sharedKey("IE_PROTO");
+      var EmptyConstructor = function() {
+      };
+      var scriptTag = function(content) {
+        return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
+      };
+      var NullProtoObjectViaActiveX = function(activeXDocument2) {
+        activeXDocument2.write(scriptTag(""));
+        activeXDocument2.close();
+        var temp = activeXDocument2.parentWindow.Object;
+        activeXDocument2 = null;
+        return temp;
+      };
+      var NullProtoObjectViaIFrame = function() {
+        var iframe = documentCreateElement("iframe");
+        var JS = "java" + SCRIPT + ":";
+        var iframeDocument;
+        iframe.style.display = "none";
+        html.appendChild(iframe);
+        iframe.src = String(JS);
+        iframeDocument = iframe.contentWindow.document;
+        iframeDocument.open();
+        iframeDocument.write(scriptTag("document.F=Object"));
+        iframeDocument.close();
+        return iframeDocument.F;
+      };
+      var activeXDocument;
+      var NullProtoObject = function() {
+        try {
+          activeXDocument = new ActiveXObject("htmlfile");
+        } catch (error) {
+        }
+        NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
+        var length = enumBugKeys.length;
+        while (length--)
+          delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+        return NullProtoObject();
+      };
+      hiddenKeys[IE_PROTO] = true;
+      module.exports = Object.create || function create(O, Properties) {
+        var result;
+        if (O !== null) {
+          EmptyConstructor[PROTOTYPE] = anObject(O);
+          result = new EmptyConstructor();
+          EmptyConstructor[PROTOTYPE] = null;
+          result[IE_PROTO] = O;
+        } else
+          result = NullProtoObject();
+        return Properties === void 0 ? result : definePropertiesModule.f(result, Properties);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/modules/es.object.create.js
+  var require_es_object_create = __commonJS({
+    "node_modules/core-js-pure/modules/es.object.create.js"() {
+      "use strict";
+      var $ = require_export();
+      var DESCRIPTORS = require_descriptors();
+      var create = require_object_create();
+      $({ target: "Object", stat: true, sham: !DESCRIPTORS }, {
+        create
+      });
+    }
+  });
+
+  // node_modules/core-js-pure/es/object/create.js
+  var require_create = __commonJS({
+    "node_modules/core-js-pure/es/object/create.js"(exports, module) {
+      "use strict";
+      require_es_object_create();
+      var path = require_path();
+      var Object2 = path.Object;
+      module.exports = function create(P, D) {
+        return Object2.create(P, D);
+      };
+    }
+  });
+
+  // node_modules/core-js-pure/stable/object/create.js
+  var require_create2 = __commonJS({
+    "node_modules/core-js-pure/stable/object/create.js"(exports, module) {
+      "use strict";
+      var parent = require_create();
+      module.exports = parent;
+    }
+  });
+
+  // node_modules/@babel/runtime-corejs3/core-js-stable/object/create.js
+  var require_create3 = __commonJS({
+    "node_modules/@babel/runtime-corejs3/core-js-stable/object/create.js"(exports, module) {
+      module.exports = require_create2();
+    }
+  });
+
+  // node_modules/classnames/index.js
+  var require_classnames = __commonJS({
+    "node_modules/classnames/index.js"(exports, module) {
+      (function() {
+        "use strict";
+        var hasOwn = {}.hasOwnProperty;
+        function classNames() {
+          var classes = "";
+          for (var i = 0; i < arguments.length; i++) {
+            var arg = arguments[i];
+            if (arg) {
+              classes = appendClass(classes, parseValue(arg));
+            }
+          }
+          return classes;
+        }
+        function parseValue(arg) {
+          if (typeof arg === "string" || typeof arg === "number") {
+            return arg;
+          }
+          if (typeof arg !== "object") {
+            return "";
+          }
+          if (Array.isArray(arg)) {
+            return classNames.apply(null, arg);
+          }
+          if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
+            return arg.toString();
+          }
+          var classes = "";
+          for (var key in arg) {
+            if (hasOwn.call(arg, key) && arg[key]) {
+              classes = appendClass(classes, key);
+            }
+          }
+          return classes;
+        }
+        function appendClass(value, newClass) {
+          if (!newClass) {
+            return value;
+          }
+          if (value) {
+            return value + " " + newClass;
+          }
+          return value + newClass;
+        }
+        if (typeof module !== "undefined" && module.exports) {
+          classNames.default = classNames;
+          module.exports = classNames;
+        } else if (typeof define === "function" && typeof define.amd === "object" && define.amd) {
+          define("classnames", [], function() {
+            return classNames;
+          });
+        } else {
+          window.classNames = classNames;
+        }
+      })();
+    }
+  });
+
+  // node_modules/inject-meta-tag/lib/esmodules/injectMetaTag.js
+  function injectMeta(name, content) {
+    try {
+      if (typeof document === "undefined") {
+        return;
+      }
+      var metaElement = document.createElement("meta");
+      metaElement.setAttribute("name", name);
+      content && metaElement.setAttribute("content", content);
+      document.head.appendChild(metaElement);
+    } catch (error) {
+      console.error('inject-meta-tag: Failed to inject <meta name="'.concat(name, '"> tag.'), error);
+    }
+  }
+
+  // src/private/FluentThemeProvider.tsx
+  var import_botframework_webchat_component9 = __toESM(require_botframework_webchat_component());
+  var import_react27 = __toESM(require_react());
+
+  // src/components/telephoneKeypad/Provider.tsx
+  var import_react2 = __toESM(require_react());
+
+  // src/components/telephoneKeypad/private/Context.ts
+  var import_react = __toESM(require_react());
+  var Context = (0, import_react.createContext)(
+    new Proxy({}, {
+      get() {
+        throw new Error("botframework-webchat: This hook can only used under its corresponding <Provider>.");
+      }
+    })
+  );
+  Context.displayName = "TelephoneKeypad.Context";
+  var Context_default = Context;
+
+  // src/components/telephoneKeypad/Provider.tsx
+  var Provider = (0, import_react2.memo)(({ children }) => {
+    const [shown, setShown] = (0, import_react2.useState)(false);
+    const context = (0, import_react2.useMemo)(
+      () => Object.freeze({
+        setShown,
+        shown
+      }),
+      [setShown, shown]
+    );
+    return /* @__PURE__ */ import_react2.default.createElement(Context_default.Provider, { value: context }, children);
+  });
+  var Provider_default = Provider;
+
+  // src/components/telephoneKeypad/Surrogate.tsx
+  var import_react8 = __toESM(require_react());
+
+  // src/components/telephoneKeypad/private/TelephoneKeypad.tsx
+  var import_react7 = __toESM(require_react());
+
+  // node_modules/use-ref-from/lib/esmodules/useRefFrom.js
+  var import_create = __toESM(require_create3());
+  var import_react3 = __toESM(require_react());
+  function useRefFrom(value) {
+    var ref = (0, import_react3.useRef)();
+    var readOnlyRef = (0, import_react3.useMemo)(function() {
+      return (0, import_create.default)({}, {
+        current: {
+          get: function get() {
+            return ref.current;
+          }
+        }
+      });
+    }, [ref]);
+    ref.current = value;
+    return readOnlyRef;
+  }
+
+  // src/components/telephoneKeypad/private/Button.tsx
+  var import_react5 = __toESM(require_react());
+
+  // src/components/telephoneKeypad/private/Button.module.css
+  var Button_default = {
+    "telephone-keypad__button": "Button_telephone-keypad__button",
+    "telephone-keypad__button__ruby": "Button_telephone-keypad__button__ruby",
+    "telephone-keypad__button__text": "Button_telephone-keypad__button__text",
+    "telephone-keypad--horizontal": "Button_telephone-keypad--horizontal"
+  };
+
+  // src/styles/injectStyle.ts
+  var injectedStyles = "/* src/components/telephoneKeypad/private/Button.module.css */\n.webchat-fluent .Button_telephone-keypad__button {\n  -webkit-user-select: none;\n  align-items: center;\n  appearance: none;\n  background-color: White;\n  border-radius: 100%;\n  border: solid 1px var(--webchat-colorNeutralStroke1);\n  color: var(--webchat-colorGray200);\n  font-weight: var(--webchat-fontWeightSemibold);\n  cursor: pointer;\n  display: flex;\n  flex-direction: column;\n  height: 60px;\n  opacity: 0.7;\n  padding: 0;\n  position: relative;\n  touch-action: none;\n  user-select: none;\n  width: 60px;\n}\n.webchat-fluent .Button_telephone-keypad__button:hover {\n  background-color: var(--webchat-colorGray30);\n}\n.webchat-fluent .Button_telephone-keypad__button__ruby {\n  color: var(--webchat-colorGray190);\n  font-size: 10px;\n}\n.webchat-fluent .Button_telephone-keypad__button__text {\n  font-size: 24px;\n  margin-top: 8px;\n}\n.webchat-fluent .Button_telephone-keypad--horizontal .Button_telephone-keypad__button {\n  height: 32px;\n  justify-content: center;\n  margin: 8px 4px;\n  width: 32px;\n}\n.webchat-fluent .Button_telephone-keypad--horizontal .Button_telephone-keypad__button__ruby {\n  display: none;\n}\n.webchat-fluent .Button_telephone-keypad--horizontal .Button_telephone-keypad__button__text {\n  font-size: 20px;\n  margin-top: 0;\n}\n\n/* src/components/telephoneKeypad/private/TelephoneKeypad.module.css */\n.webchat-fluent .TelephoneKeypad_telephone-keypad {\n  align-items: center;\n  background: var(--webchat-colorNeutralBackground1);\n  border: none;\n  border-radius: var(--webchat-borderRadiusXLarge);\n  display: flex;\n  flex-direction: column;\n  font-family: var(--webchat-fontFamilyBase);\n  justify-content: center;\n}\n.webchat-fluent .TelephoneKeypad_telephone-keypad__box {\n  box-sizing: border-box;\n  display: grid;\n  gap: 16px;\n  grid-template-columns: repeat(3, 1fr);\n  grid-template-rows: repeat(4, 1fr);\n  justify-items: center;\n  padding: 16px;\n  width: 100%;\n}\n\n/* src/components/Theme.module.css */\n.webchat-fluent.Theme_theme {\n  display: contents;\n  --webchat-colorNeutralForeground1: var(--colorNeutralForeground1, #242424);\n  --webchat-colorNeutralForeground2: var(--colorNeutralForeground2, #424242);\n  --webchat-colorNeutralForeground4: var(--colorNeutralForeground4, #707070);\n  --webchat-colorNeutralForegroundDisabled: var(--colorNeutralForegroundDisabled, #bdbdbd);\n  --webchat-colorNeutralBackground1: var(--colorNeutralBackground1, #ffffff);\n  --webchat-colorNeutralBackground4: var(--colorNeutralBackground4, #f0f0f0);\n  --webchat-colorNeutralBackground5: var(--colorNeutralBackground5, #ebebeb);\n  --webchat-colorSubtleBackgroundHover: var(--colorSubtleBackgroundHover, #f5f5f5);\n  --webchat-colorSubtleBackgroundPressed: var(--colorSubtleBackgroundPressed, #e0e0e0);\n  --webchat-colorNeutralStroke1: var(--colorNeutralStroke1, #d1d1d1);\n  --webchat-colorNeutralStroke2: var(--colorNeutralStroke2, #e0e0e0);\n  --webchat-colorNeutralStroke1Selected: var(--colorNeutralStroke1Selected, #bdbdbd);\n  --webchat-colorBrandStroke2: var(--colorBrandStroke2, #9edcf7);\n  --webchat-colorBrandForeground2Hover: var(--colorBrandForeground2Hover, #015a7a);\n  --webchat-colorBrandForeground2Pressed: var(--colorBrandForeground2Pressed, #01384d);\n  --webchat-colorBrandBackground2Hover: var(--colorBrandBackground2Hover, #bee7fa);\n  --webchat-colorBrandBackground2Pressed: var(--colorBrandBackground2Pressed, #7fd2f5);\n  --webchat-colorCompoundBrandForeground1: var(--colorCompoundBrandForeground1, #077fab);\n  --webchat-colorCompoundBrandForeground1Hover: var(--colorCompoundBrandForeground1Hover, #02729c);\n  --webchat-colorCompoundBrandForeground1Pressed: var(--colorCompoundBrandForeground1Pressed, #01678c);\n  --webchat-colorStatusDangerForeground1: var(--colorStatusDangerForeground1, #b10e1c);\n  --webchat-colorGray30: var(--colorGray30, #edebe9);\n  --webchat-colorGray160: var(--colorGray160, #323130);\n  --webchat-colorGray190: var(--colorGray190, #201f1e);\n  --webchat-colorGray200: var(--colorGray200, #1b1a19);\n  --webchat-borderRadiusSmall: var(--borderRadiusSmall, 2px);\n  --webchat-borderRadiusLarge: var(--borderRadiusLarge, 6px);\n  --webchat-borderRadiusXLarge: var(--borderRadiusXLarge, 8px);\n  --webchat-shadow16: var(--shadow16, 0 6.4px 14.4px 0 rgba(0, 0, 0, 0.132), 0 1.2px 3.6px 0 rgba(0, 0, 0, 0.108));\n  --webchat-spacingHorizontalMNudge: var(--spacingHorizontalMNudge, 10px);\n  --webchat-fontFamilyBase: var(--fontFamilyBase, \"Segoe UI\", \"Segoe UI Web (West European)\", -apple-system, BlinkMacSystemFont, Roboto, \"Helvetica Neue\", sans-serif);\n  --webchat-fontFamilyNumeric: var(--fontFamilyNumeric, Bahnschrift, \"Segoe UI\", \"Segoe UI Web (West European)\", -apple-system, BlinkMacSystemFont, Roboto, \"Helvetica Neue\", sans-serif);\n  --webchat-fontWeightSemibold: var(--fontWeightSemibold, 600);\n}\n\n/* src/components/dropZone/index.module.css */\n.webchat-fluent .dropZone_sendbox__attachment-drop-zone {\n  background-color: var(--webchat-colorNeutralBackground4);\n  border-radius: inherit;\n  cursor: copy;\n  display: grid;\n  gap: 8px;\n  inset: 0;\n  place-content: center;\n  place-items: center;\n  position: absolute;\n}\n.webchat-fluent .dropZone_sendbox__attachment-drop-zone--droppable {\n  background-color: #e00;\n  color: White;\n}\n.webchat-fluent .dropZone_sendbox__attachment-drop-zone-icon {\n  height: 36px;\n  pointer-events: none;\n  width: 36px;\n}\n\n/* src/components/suggestedActions/SuggestedAction.module.css */\n.webchat-fluent .SuggestedAction_suggested-action {\n  align-items: center;\n  background: transparent;\n  border-radius: 8px;\n  border: 1px solid var(--webchat-colorBrandStroke2);\n  cursor: pointer;\n  display: flex;\n  font-size: 12px;\n  gap: 4px;\n  padding: 4px 8px 4px;\n  text-align: start;\n  transition: all .15s ease-out;\n}\n@media (hover: hover) {\n  .webchat-fluent .SuggestedAction_suggested-action:not([aria-disabled=true]):hover {\n    background-color: var(--webchat-colorBrandBackground2Hover);\n    color: var(--webchat-colorBrandForeground2Hover);\n  }\n}\n.webchat-fluent .SuggestedAction_suggested-action:not([aria-disabled=true]):active {\n  background-color: var(--webchat-colorBrandBackground2Pressed);\n  color: var(--webchat-colorBrandForeground2Pressed);\n}\n.webchat-fluent .SuggestedAction_suggested-action[aria-disabled=true] {\n  color: var(--webchat-colorNeutralForegroundDisabled);\n  cursor: not-allowed;\n}\n.webchat-fluent .SuggestedAction_suggested-action__image {\n  font-size: 12px;\n  height: 1em;\n  width: 1em;\n}\n\n/* src/components/suggestedActions/index.module.css */\n.webchat-fluent .suggestedActions_suggested-actions {\n  align-items: flex-end;\n  align-self: flex-end;\n  display: flex;\n  flex-direction: column;\n  gap: 8px;\n}\n.webchat-fluent .suggestedActions_suggested-actions:not(:empty) {\n  padding-block-end: 8px;\n  padding-inline-start: 4px;\n}\n.webchat-fluent .suggestedActions_suggested-actions.suggestedActions_suggested-actions--flow {\n  flex-direction: row;\n  flex-wrap: wrap;\n  justify-content: flex-end;\n}\n.webchat-fluent .suggestedActions_suggested-actions.suggestedActions_suggested-actions--stacked {\n  flex-direction: column;\n}\n\n/* src/components/sendbox/Toolbar.module.css */\n.webchat-fluent .Toolbar_sendbox__toolbar {\n  display: flex;\n  gap: 4px;\n  margin-inline-start: auto;\n}\n.webchat-fluent .Toolbar_sendbox__toolbar-button {\n  align-items: center;\n  appearance: none;\n  aspect-ratio: 1;\n  background: transparent;\n  border-radius: var(--webchat-borderRadiusSmall);\n  border: none;\n  cursor: pointer;\n  display: flex;\n  justify-content: center;\n  padding: 3px;\n  width: 32px;\n}\n.webchat-fluent .Toolbar_sendbox__toolbar-button > svg {\n  font-size: 20px;\n  pointer-events: none;\n}\n@media (hover: hover) {\n  .webchat-fluent .Toolbar_sendbox__toolbar-button:not([aria-disabled=true]):hover {\n    background-color: var(--webchat-colorSubtleBackgroundHover);\n    color: var(--webchat-colorCompoundBrandForeground1Hover);\n  }\n}\n.webchat-fluent .Toolbar_sendbox__toolbar-button:not([aria-disabled=true]):active {\n  background-color: var(--webchat-colorSubtleBackgroundPressed);\n  color: var(--webchat-colorCompoundBrandForeground1Pressed);\n}\n.webchat-fluent .Toolbar_sendbox__toolbar-button[aria-disabled=true] {\n  color: var(--webchat-colorNeutralForegroundDisabled);\n  cursor: not-allowed;\n}\n.webchat-fluent .Toolbar_sendbox__toolbar-separator {\n  align-self: center;\n  border-inline-end: 1px solid var(--webchat-colorNeutralStroke2);\n  height: 28px;\n}\n.webchat-fluent .Toolbar_sendbox__toolbar-separator:is(:first-child, :last-child, :only-child) {\n  display: none;\n}\n\n/* src/components/sendbox/AddAttachmentButton.module.css */\n.webchat-fluent .AddAttachmentButton_sendbox__add-attachment {\n  display: grid;\n}\n.webchat-fluent .AddAttachmentButton_sendbox__add-attachment-input {\n  font-size: 0;\n  height: 0;\n  opacity: 0;\n  width: 0;\n}\n\n/* src/components/sendbox/Attachments.module.css */\n.webchat-fluent .Attachments_sendbox__attachment {\n  border-radius: var(--webchat-borderRadiusLarge);\n  border: 1px solid var(--webchat-colorNeutralStroke1);\n  cursor: default;\n  padding: 6px 8px;\n  width: fit-content;\n}\n\n/* src/components/sendbox/ErrorMessage.module.css */\n.webchat-fluent .ErrorMessage_sendbox__error-message {\n  color: transparent;\n  font-size: 0;\n  height: 0;\n  left: 0;\n  position: absolute;\n  top: 0;\n  width: 0;\n}\n\n/* src/components/sendbox/TextArea.module.css */\n.webchat-fluent .TextArea_sendbox__text-area {\n  display: grid;\n  grid-template-areas: \"main\";\n  max-height: 200px;\n  overflow: hidden;\n}\n.webchat-fluent .TextArea_sendbox__text-area--hidden {\n  height: 0;\n  visibility: collapse;\n}\n.webchat-fluent .TextArea_sendbox__text-area-shared {\n  border: none;\n  font: inherit;\n  grid-area: main;\n  outline: inherit;\n  overflow-wrap: anywhere;\n  resize: inherit;\n  scrollbar-gutter: stable;\n}\n.webchat-fluent .TextArea_sendbox__text-area-doppelganger {\n  overflow: hidden;\n  visibility: hidden;\n  white-space: pre-wrap;\n}\n.webchat-fluent .TextArea_sendbox__text-area-input {\n  height: 100%;\n  padding: 0;\n}\n.webchat-fluent .TextArea_sendbox__text-area-input--scroll {\n  scrollbar-color: unset;\n  scrollbar-width: unset;\n  -moz-scrollbar-color: var(--webchat-colorNeutralBackground5) var(--webchat-colorNeutralForeground2);\n  -moz-scrollbar-width: thin;\n}\n.webchat-fluent .TextArea_sendbox__text-area-input--scroll::-webkit-scrollbar {\n  width: 8px;\n}\n.webchat-fluent .TextArea_sendbox__text-area-input--scroll::-webkit-scrollbar-track {\n  background-color: var(--webchat-colorNeutralBackground5);\n  border-radius: 16px;\n}\n.webchat-fluent .TextArea_sendbox__text-area-input--scroll::-webkit-scrollbar-thumb {\n  background-color: var(--webchat-colorNeutralForeground2);\n  border-radius: 16px;\n}\n.webchat-fluent .TextArea_sendbox__text-area-input--scroll::-webkit-scrollbar-corner {\n  background-color: var(--webchat-colorNeutralBackground5);\n}\n\n/* src/components/sendbox/index.module.css */\n.webchat-fluent .sendbox_sendbox {\n  color: var(--webchat-colorNeutralForeground1);\n  font-family: var(--webchat-fontFamilyBase);\n  padding: 0 10px 10px;\n  text-rendering: optimizeLegibility;\n}\n.webchat-fluent .sendbox_sendbox__sendbox {\n  background-color: var(--webchat-colorNeutralBackground1);\n  border-radius: var(--webchat-borderRadiusLarge);\n  border: 1px solid var(--webchat-colorNeutralStroke1);\n  display: grid;\n  font-family: var(--webchat-fontFamilyBase);\n  font-size: 14px;\n  gap: 6px;\n  line-height: 20px;\n  padding: 8px;\n  position: relative;\n}\n.webchat-fluent .sendbox_sendbox__sendbox:focus-within {\n  border-color: var(--webchat-colorNeutralStroke1Selected);\n  box-shadow: inset 0 -6px 0 -3px var(--webchat-colorCompoundBrandForeground1Hover);\n}\n.webchat-fluent .sendbox_sendbox__sendbox-text {\n  background-color: transparent;\n  border: none;\n  flex: auto;\n  font-family: var(--webchat-fontFamilyBase);\n  font-size: 14px;\n  line-height: 20px;\n  outline: none;\n  padding: 4px 4px 0;\n  resize: none;\n}\n.webchat-fluent .sendbox_sendbox__sendbox-controls {\n  align-items: center;\n  display: flex;\n  padding-inline-start: 4px;\n}\n.webchat-fluent .sendbox_sendbox__text-counter {\n  color: var(--webchat-colorNeutralForeground4);\n  cursor: default;\n  font-family: var(--webchat-fontFamilyNumeric);\n  font-size: 10px;\n  line-height: 14px;\n}\n.webchat-fluent .sendbox_sendbox__text-counter--error {\n  color: var(--webchat-colorStatusDangerForeground1);\n}\n";
+  function injectStyles() {
+    if (globalThis.document) {
+      const style = document.createElement("style");
+      style.append(document.createTextNode(injectedStyles));
+      document.head.appendChild(style);
+    }
+  }
+
+  // src/styles/useStyles.ts
+  var import_react4 = __toESM(require_react());
+  function useStyles(styles) {
+    return (0, import_react4.useMemo)(
+      () => Object.freeze(
+        Object.fromEntries(
+          Object.entries(styles).map(([baseClassName, resultClassName]) => [
+            baseClassName,
+            `${baseClassName} ${resultClassName}`
+          ])
+        )
+      ),
+      [styles]
+    );
+  }
+  var useStyles_default = useStyles;
+
+  // src/components/telephoneKeypad/private/Button.tsx
+  var Button = (0, import_react5.memo)(
+    // As we are all TypeScript, internal components do not need propTypes.
+    // eslint-disable-next-line react/prop-types
+    (0, import_react5.forwardRef)(({ button, "data-testid": dataTestId, onClick, ruby }, ref) => {
+      const classNames = useStyles_default(Button_default);
+      const onClickRef = useRefFrom(onClick);
+      const handleClick = (0, import_react5.useCallback)(() => onClickRef.current?.(), [onClickRef]);
+      return /* @__PURE__ */ import_react5.default.createElement(
+        "button",
+        {
+          className: classNames["telephone-keypad__button"],
+          "data-testid": dataTestId,
+          onClick: handleClick,
+          ref,
+          type: "button"
+        },
+        /* @__PURE__ */ import_react5.default.createElement("span", { className: classNames["telephone-keypad__button__text"] }, button === "star" ? "\u2217" : button === "pound" ? "#" : button),
+        !!ruby && /* @__PURE__ */ import_react5.default.createElement("ruby", { className: classNames["telephone-keypad__button__ruby"] }, ruby)
+      );
+    })
+  );
+  Button.displayName = "TelephoneKeypad.Button";
+  var Button_default2 = Button;
+
+  // src/testIds.ts
+  var testIds = {
+    sendBoxDropZone: "send box drop zone",
+    sendBoxSendButton: "send box send button",
+    sendBoxTextBox: "send box text area",
+    sendBoxTelephoneKeypadButton1: `send box telephone keypad button 1`,
+    sendBoxTelephoneKeypadButton2: `send box telephone keypad button 2`,
+    sendBoxTelephoneKeypadButton3: `send box telephone keypad button 3`,
+    sendBoxTelephoneKeypadButton4: `send box telephone keypad button 4`,
+    sendBoxTelephoneKeypadButton5: `send box telephone keypad button 5`,
+    sendBoxTelephoneKeypadButton6: `send box telephone keypad button 6`,
+    sendBoxTelephoneKeypadButton7: `send box telephone keypad button 7`,
+    sendBoxTelephoneKeypadButton8: `send box telephone keypad button 8`,
+    sendBoxTelephoneKeypadButton9: `send box telephone keypad button 9`,
+    sendBoxTelephoneKeypadButton0: `send box telephone keypad button 0`,
+    sendBoxTelephoneKeypadButtonStar: `send box telephone keypad button star`,
+    sendBoxTelephoneKeypadButtonPound: `send box telephone keypad button pound`,
+    sendBoxTelephoneKeypadToolbarButton: "send box telephone keypad toolbar button",
+    sendBoxUploadButton: "send box upload button"
+  };
+  var testIds_default = testIds;
+
+  // src/components/telephoneKeypad/useShown.ts
+  var import_react6 = __toESM(require_react());
+  function useShown() {
+    const { setShown, shown } = (0, import_react6.useContext)(Context_default);
+    return (0, import_react6.useMemo)(() => Object.freeze([shown, setShown]), [shown, setShown]);
+  }
+
+  // src/components/telephoneKeypad/private/TelephoneKeypad.module.css
+  var TelephoneKeypad_default = {
+    "telephone-keypad": "TelephoneKeypad_telephone-keypad",
+    "telephone-keypad__box": "TelephoneKeypad_telephone-keypad__box"
+  };
+
+  // src/components/telephoneKeypad/private/TelephoneKeypad.tsx
+  var Orientation = (0, import_react7.memo)(
+    ({ children, isHorizontal }) => {
+      const classNames = useStyles_default(TelephoneKeypad_default);
+      return isHorizontal ? (
+        // <HorizontalDialPadController>{children}</HorizontalDialPadController>
+        false
+      ) : /* @__PURE__ */ import_react7.default.createElement("div", { className: classNames["telephone-keypad__box"] }, children);
+    }
+  );
+  Orientation.displayName = "TelephoneKeypad:Orientation";
+  var TelephoneKeypad = (0, import_react7.memo)(({ autoFocus, onButtonClick, isHorizontal }) => {
+    const autoFocusRef = useRefFrom(autoFocus);
+    const classNames = useStyles_default(TelephoneKeypad_default);
+    const firstButtonRef = (0, import_react7.useRef)(null);
+    const onButtonClickRef = useRefFrom(onButtonClick);
+    const [, setShown] = useShown();
+    const handleButton1Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("1"), [onButtonClickRef]);
+    const handleButton2Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("2"), [onButtonClickRef]);
+    const handleButton3Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("3"), [onButtonClickRef]);
+    const handleButton4Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("4"), [onButtonClickRef]);
+    const handleButton5Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("5"), [onButtonClickRef]);
+    const handleButton6Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("6"), [onButtonClickRef]);
+    const handleButton7Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("7"), [onButtonClickRef]);
+    const handleButton8Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("8"), [onButtonClickRef]);
+    const handleButton9Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("9"), [onButtonClickRef]);
+    const handleButton0Click = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("0"), [onButtonClickRef]);
+    const handleButtonStarClick = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("star"), [onButtonClickRef]);
+    const handleButtonPoundClick = (0, import_react7.useCallback)(() => onButtonClickRef.current?.("pound"), [onButtonClickRef]);
+    const handleKeyDown = (0, import_react7.useCallback)(
+      (event) => {
+        if (event.key === "Escape") {
+          setShown(false);
+        }
+      },
+      [setShown]
+    );
+    (0, import_react7.useEffect)(() => {
+      autoFocusRef.current && firstButtonRef.current?.focus();
+    }, [autoFocusRef, firstButtonRef]);
+    return /* @__PURE__ */ import_react7.default.createElement("div", { className: classNames["telephone-keypad"], onKeyDown: handleKeyDown }, /* @__PURE__ */ import_react7.default.createElement(Orientation, { isHorizontal }, /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "1",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton1,
+        onClick: handleButton1Click,
+        ref: firstButtonRef
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "2",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton2,
+        onClick: handleButton2Click,
+        ruby: "ABC"
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "3",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton3,
+        onClick: handleButton3Click,
+        ruby: "DEF"
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "4",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton4,
+        onClick: handleButton4Click,
+        ruby: "GHI"
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "5",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton5,
+        onClick: handleButton5Click,
+        ruby: "JKL"
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "6",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton6,
+        onClick: handleButton6Click,
+        ruby: "MNO"
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "7",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton7,
+        onClick: handleButton7Click,
+        ruby: "PQRS"
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "8",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton8,
+        onClick: handleButton8Click,
+        ruby: "TUV"
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "9",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButton9,
+        onClick: handleButton9Click,
+        ruby: "WXYZ"
+      }
+    ), /* @__PURE__ */ import_react7.default.createElement(Button_default2, { button: "star", "data-testid": testIds_default.sendBoxTelephoneKeypadButtonStar, onClick: handleButtonStarClick }), /* @__PURE__ */ import_react7.default.createElement(Button_default2, { button: "0", "data-testid": testIds_default.sendBoxTelephoneKeypadButton0, onClick: handleButton0Click, ruby: "+" }), /* @__PURE__ */ import_react7.default.createElement(
+      Button_default2,
+      {
+        button: "pound",
+        "data-testid": testIds_default.sendBoxTelephoneKeypadButtonPound,
+        onClick: handleButtonPoundClick
+      }
+    )));
+  });
+  TelephoneKeypad.displayName = "TelephoneKeypad";
+  var TelephoneKeypad_default2 = TelephoneKeypad;
+
+  // src/components/telephoneKeypad/Surrogate.tsx
+  var TelephoneKeypadSurrogate = (0, import_react8.memo)((props) => useShown()[0] ? /* @__PURE__ */ import_react8.default.createElement(TelephoneKeypad_default2, { ...props }) : false);
+  TelephoneKeypadSurrogate.displayName = "TelephoneKeypad.Surrogate";
+  var Surrogate_default = TelephoneKeypadSurrogate;
+
+  // src/components/Theme.tsx
+  var import_react9 = __toESM(require_react());
+  var import_classnames = __toESM(require_classnames());
+
+  // src/components/Theme.module.css
+  var Theme_default = {
+    theme: "Theme_theme"
+  };
+
+  // src/components/Theme.tsx
+  var rootClassName = "webchat-fluent";
+  function WebchatTheme(props) {
+    const classNames = useStyles_default(Theme_default);
+    return /* @__PURE__ */ import_react9.default.createElement("div", { className: (0, import_classnames.default)(rootClassName, classNames["theme"]) }, props.children);
+  }
+
+  // src/components/sendbox/index.tsx
+  var import_botframework_webchat_component8 = __toESM(require_botframework_webchat_component());
+  var import_classnames7 = __toESM(require_classnames());
+  var import_react26 = __toESM(require_react());
+
+  // src/icons/SendIcon.tsx
+  var import_react10 = __toESM(require_react());
+  function SendIcon(props) {
+    return /* @__PURE__ */ import_react10.default.createElement(
+      "svg",
+      {
+        "aria-hidden": "true",
+        className: props.className,
+        fill: "currentColor",
+        height: "1em",
+        viewBox: "0 0 20 20",
+        width: "1em",
+        xmlns: "http://www.w3.org/2000/svg"
+      },
+      /* @__PURE__ */ import_react10.default.createElement(
+        "path",
+        {
+          d: "M2.18 2.11a.5.5 0 0 1 .54-.06l15 7.5a.5.5 0 0 1 0 .9l-15 7.5a.5.5 0 0 1-.7-.58L3.98 10 2.02 2.63a.5.5 0 0 1 .16-.52Zm2.7 8.39-1.61 6.06L16.38 10 3.27 3.44 4.88 9.5h6.62a.5.5 0 1 1 0 1H4.88Z",
+          fill: "currentColor"
+        }
+      )
+    );
+  }
+
+  // src/components/dropZone/index.tsx
+  var import_botframework_webchat_component = __toESM(require_botframework_webchat_component());
+  var import_classnames2 = __toESM(require_classnames());
+  var import_react12 = __toESM(require_react());
+
+  // src/icons/AddDocumentIcon.tsx
+  var import_react11 = __toESM(require_react());
+  function AddDocumentIcon(props) {
+    return /* @__PURE__ */ import_react11.default.createElement(
+      "svg",
+      {
+        "aria-hidden": "true",
+        className: props.className,
+        fill: "currentColor",
+        height: "1em",
+        viewBox: "0 0 20 20",
+        width: "1em",
+        xmlns: "http://www.w3.org/2000/svg"
+      },
+      /* @__PURE__ */ import_react11.default.createElement(
+        "path",
+        {
+          d: "M6 2a2 2 0 0 0-2 2v5.2c.32-.08.66-.15 1-.18V4a1 1 0 0 1 1-1h4v3.5c0 .83.67 1.5 1.5 1.5H15v8a1 1 0 0 1-1 1h-3.6c-.18.36-.4.7-.66 1H14a2 2 0 0 0 2-2V7.41c0-.4-.16-.78-.44-1.06l-3.91-3.91A1.5 1.5 0 0 0 10.59 2H6Zm8.8 5h-3.3a.5.5 0 0 1-.5-.5V3.2L14.8 7ZM10 14.5a4.5 4.5 0 1 1-9 0 4.5 4.5 0 0 1 9 0Zm-4-2a.5.5 0 0 0-1 0V14H3.5a.5.5 0 0 0 0 1H5v1.5a.5.5 0 0 0 1 0V15h1.5a.5.5 0 0 0 0-1H6v-1.5Z",
+          fill: "currentColor"
+        }
+      )
+    );
+  }
+
+  // src/components/dropZone/index.module.css
+  var dropZone_default = {
+    "sendbox__attachment-drop-zone": "dropZone_sendbox__attachment-drop-zone",
+    "sendbox__attachment-drop-zone--droppable": "dropZone_sendbox__attachment-drop-zone--droppable",
+    "sendbox__attachment-drop-zone-icon": "dropZone_sendbox__attachment-drop-zone-icon"
+  };
+
+  // src/components/dropZone/index.tsx
+  var { useLocalizer } = import_botframework_webchat_component.hooks;
+  var handleDragOver = (event) => {
+    event.preventDefault();
+  };
+  var isFilesTransferEvent = (event) => !!event.dataTransfer?.types?.some((type) => type.toLowerCase() === "files");
+  function isDescendantOf(target, ancestor) {
+    let current = target.parentNode;
+    while (current) {
+      if (current === ancestor) {
+        return true;
+      }
+      current = current.parentNode;
+    }
+    return false;
+  }
+  var DropZone = (props) => {
+    const [dropZoneState, setDropZoneState] = (0, import_react12.useState)(false);
+    const classNames = useStyles_default(dropZone_default);
+    const dropZoneRef = (0, import_react12.useRef)(null);
+    const localize = useLocalizer();
+    const onFilesAddedRef = useRefFrom(props.onFilesAdded);
+    (0, import_react12.useEffect)(() => {
+      let entranceCounter = 0;
+      const handleDragEnter = (event) => {
+        entranceCounter++;
+        if (isFilesTransferEvent(event)) {
+          setDropZoneState(
+            dropZoneRef.current && (event.target === dropZoneRef.current || event.target instanceof HTMLElement && isDescendantOf(event.target, dropZoneRef.current)) ? "droppable" : "visible"
+          );
+        }
+      };
+      const handleDragLeave = () => --entranceCounter <= 0 && setDropZoneState(false);
+      document.addEventListener("dragenter", handleDragEnter, false);
+      document.addEventListener("dragleave", handleDragLeave, false);
+      return () => {
+        document.removeEventListener("dragenter", handleDragEnter);
+        document.removeEventListener("dragleave", handleDragLeave);
+      };
+    }, [setDropZoneState]);
+    const handleDrop = (0, import_react12.useCallback)(
+      (event) => {
+        event.preventDefault();
+        setDropZoneState(false);
+        if (!isFilesTransferEvent(event.nativeEvent)) {
+          return;
+        }
+        onFilesAddedRef.current([...event.dataTransfer.files]);
+      },
+      [onFilesAddedRef, setDropZoneState]
+    );
+    return dropZoneState ? /* @__PURE__ */ import_react12.default.createElement(
+      "div",
+      {
+        className: (0, import_classnames2.default)(classNames["sendbox__attachment-drop-zone"], {
+          [classNames["sendbox__attachment-drop-zone--droppable"]]: dropZoneState === "droppable"
+        }),
+        "data-testid": testIds_default.sendBoxDropZone,
+        onDragOver: handleDragOver,
+        onDrop: handleDrop,
+        ref: dropZoneRef
+      },
+      /* @__PURE__ */ import_react12.default.createElement(AddDocumentIcon, { className: classNames["sendbox__attachment-drop-zone-icon"] }),
+      localize("TEXT_INPUT_DROP_ZONE")
+    ) : null;
+  };
+  DropZone.displayName = "DropZone";
+  var dropZone_default2 = (0, import_react12.memo)(DropZone);
+
+  // src/components/DropZone.tsx
+  var DropZone_default = dropZone_default2;
+
+  // src/components/suggestedActions/index.tsx
+  var import_botframework_webchat_component3 = __toESM(require_botframework_webchat_component());
+  var import_classnames4 = __toESM(require_classnames());
+  var import_react15 = __toESM(require_react());
+
+  // src/components/suggestedActions/SuggestedAction.tsx
+  var import_botframework_webchat_component2 = __toESM(require_botframework_webchat_component());
+  var import_classnames3 = __toESM(require_classnames());
+  var import_react14 = __toESM(require_react());
+
+  // src/components/suggestedActions/SuggestedAction.module.css
+  var SuggestedAction_default = {
+    "suggested-action": "SuggestedAction_suggested-action",
+    "suggested-action__image": "SuggestedAction_suggested-action__image"
+  };
+
+  // src/components/suggestedActions/AccessibleButton.tsx
+  var import_react13 = __toESM(require_react());
+  var preventDefaultHandler = (event) => event.preventDefault();
+  var AccessibleButton = (0, import_react13.forwardRef)(
+    ({ "aria-hidden": ariaHidden, children, disabled, onClick, tabIndex, ...props }, forwardedRef) => {
+      const targetRef = (0, import_react13.useRef)(null);
+      const ref = forwardedRef || targetRef;
+      return /* @__PURE__ */ import_react13.default.createElement(
+        "button",
+        {
+          "aria-disabled": disabled ? "true" : "false",
+          "aria-hidden": ariaHidden,
+          onClick: disabled ? preventDefaultHandler : onClick,
+          ref,
+          tabIndex,
+          ...disabled && {
+            "aria-disabled": "true",
+            tabIndex: -1
+          },
+          ...props,
+          type: "button"
+        },
+        children
+      );
+    }
+  );
+  var AccessibleButton_default = (0, import_react13.memo)(AccessibleButton);
+
+  // src/components/suggestedActions/SuggestedAction.tsx
+  var { useDisabled, useFocus, usePerformCardAction, useScrollToEnd, useStyleSet, useSuggestedActions } = import_botframework_webchat_component2.hooks;
+  function SuggestedAction({
+    buttonText,
+    className,
+    displayText,
+    image,
+    imageAlt,
+    text,
+    type,
+    value
+  }) {
+    const [_, setSuggestedActions] = useSuggestedActions();
+    const [{ suggestedAction: suggestedActionStyleSet }] = useStyleSet();
+    const [disabled] = useDisabled();
+    const focus = useFocus();
+    const focusRef = (0, import_react14.useRef)(null);
+    const performCardAction = usePerformCardAction();
+    const classNames = useStyles_default(SuggestedAction_default);
+    const scrollToEnd = useScrollToEnd();
+    const handleClick = (0, import_react14.useCallback)(
+      ({ target }) => {
+        (async function() {
+          await focus("sendBoxWithoutKeyboard");
+          performCardAction({ displayText, text, type, value }, { target });
+          type === "openUrl" && setSuggestedActions([]);
+          scrollToEnd();
+        })();
+      },
+      [displayText, focus, performCardAction, scrollToEnd, setSuggestedActions, text, type, value]
+    );
+    return /* @__PURE__ */ import_react14.default.createElement(
+      AccessibleButton_default,
+      {
+        className: (0, import_classnames3.default)(classNames["suggested-action"], suggestedActionStyleSet + "", (className || "") + ""),
+        disabled,
+        onClick: handleClick,
+        ref: focusRef,
+        type: "button"
+      },
+      image && /* @__PURE__ */ import_react14.default.createElement("img", { alt: imageAlt, className: classNames["suggested-action__image"], src: image }),
+      /* @__PURE__ */ import_react14.default.createElement("span", null, buttonText)
+    );
+  }
+  var SuggestedAction_default2 = (0, import_react14.memo)(SuggestedAction);
+
+  // src/components/suggestedActions/private/computeSuggestedActionText.ts
+  function computeSuggestedActionText(cardAction) {
+    const { title } = cardAction;
+    const { type, value } = cardAction;
+    if (type === "messageBack") {
+      return title || cardAction.displayText;
+    } else if (title) {
+      return title;
+    } else if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+
+  // src/components/suggestedActions/index.module.css
+  var suggestedActions_default = {
+    "suggested-actions": "suggestedActions_suggested-actions",
+    "suggested-actions--flow": "suggestedActions_suggested-actions--flow",
+    "suggested-actions--stacked": "suggestedActions_suggested-actions--stacked"
+  };
+
+  // src/components/suggestedActions/index.tsx
+  var { useLocalizer: useLocalizer2, useStyleOptions, useStyleSet: useStyleSet2, useSuggestedActions: useSuggestedActions2 } = import_botframework_webchat_component3.hooks;
+  function SuggestedActionStackedOrFlowContainer(props) {
+    const [{ suggestedActionLayout }] = useStyleOptions();
+    const [{ suggestedActions: suggestedActionsStyleSet }] = useStyleSet2();
+    const classNames = useStyles_default(suggestedActions_default);
+    return /* @__PURE__ */ import_react15.default.createElement(
+      "div",
+      {
+        "aria-label": props["aria-label"],
+        "aria-live": "polite",
+        "aria-orientation": "vertical",
+        className: (0, import_classnames4.default)(
+          classNames["suggested-actions"],
+          suggestedActionsStyleSet + "",
+          {
+            [classNames["suggested-actions--flow"]]: suggestedActionLayout === "flow",
+            [classNames["suggested-actions--stacked"]]: suggestedActionLayout !== "flow"
+          },
+          props.className
+        ),
+        role: "toolbar"
+      },
+      !!props.children && !!import_react15.default.Children.count(props.children) && props.children
+    );
+  }
+  function SuggestedActions() {
+    const classNames = useStyles_default(suggestedActions_default);
+    const localize = useLocalizer2();
+    const [suggestedActions] = useSuggestedActions2();
+    const children = suggestedActions.map((cardAction, index) => {
+      const { displayText, image, imageAltText, text, type, value } = cardAction;
+      if (!suggestedActions?.length) {
+        return null;
+      }
+      return /* @__PURE__ */ import_react15.default.createElement(
+        SuggestedAction_default2,
+        {
+          buttonText: computeSuggestedActionText(cardAction),
+          displayText,
+          image,
+          imageAlt: image && (imageAltText || text),
+          itemIndex: index,
+          key: index,
+          text,
+          type,
+          value
+        }
+      );
+    });
+    return /* @__PURE__ */ import_react15.default.createElement(
+      SuggestedActionStackedOrFlowContainer,
+      {
+        "aria-label": localize("SUGGESTED_ACTIONS_LABEL_ALT"),
+        className: classNames["suggested-actions"]
+      },
+      children
+    );
+  }
+  var suggestedActions_default2 = (0, import_react15.memo)(SuggestedActions);
+
+  // src/components/SuggestedActions.tsx
+  var SuggestedActions_default = suggestedActions_default2;
+
+  // src/components/sendbox/AddAttachmentButton.tsx
+  var import_botframework_webchat_component4 = __toESM(require_botframework_webchat_component());
+  var import_react18 = __toESM(require_react());
+
+  // src/icons/AttachmentIcon.tsx
+  var import_react16 = __toESM(require_react());
+  function AttachmentIcon(props) {
+    return /* @__PURE__ */ import_react16.default.createElement(
+      "svg",
+      {
+        "aria-hidden": "true",
+        className: props.className,
+        fill: "currentColor",
+        height: "1em",
+        viewBox: "0 0 20 20",
+        width: "1em",
+        xmlns: "http://www.w3.org/2000/svg"
+      },
+      /* @__PURE__ */ import_react16.default.createElement(
+        "path",
+        {
+          d: "m4.83 10.48 5.65-5.65a3 3 0 0 1 4.25 4.24L8 15.8a1.5 1.5 0 0 1-2.12-2.12l6-6.01a.5.5 0 1 0-.7-.71l-6 6.01a2.5 2.5 0 0 0 3.53 3.54l6.71-6.72a4 4 0 1 0-5.65-5.66L4.12 9.78a.5.5 0 0 0 .7.7Z",
+          fill: "currentColor"
+        }
+      )
+    );
+  }
+
+  // src/components/sendbox/Toolbar.tsx
+  var import_classnames5 = __toESM(require_classnames());
+  var import_react17 = __toESM(require_react());
+
+  // src/components/sendbox/Toolbar.module.css
+  var Toolbar_default = {
+    sendbox__toolbar: "Toolbar_sendbox__toolbar",
+    "sendbox__toolbar-button": "Toolbar_sendbox__toolbar-button",
+    "sendbox__toolbar-separator": "Toolbar_sendbox__toolbar-separator"
+  };
+
+  // src/components/sendbox/Toolbar.tsx
+  var preventDefaultHandler2 = (event) => event.preventDefault();
+  var ToolbarButton = (0, import_react17.memo)(
+    (props) => {
+      const classNames = useStyles_default(Toolbar_default);
+      return /* @__PURE__ */ import_react17.default.createElement(
+        "button",
+        {
+          "aria-label": props["aria-label"],
+          className: (0, import_classnames5.default)(classNames["sendbox__toolbar-button"], props.className),
+          "data-testid": props["data-testid"],
+          onClick: props.disabled ? preventDefaultHandler2 : props.onClick,
+          type: props.type === "submit" ? "submit" : "button",
+          ...props.disabled && {
+            "aria-disabled": "true",
+            tabIndex: -1
+          }
+        },
+        props.children
+      );
+    }
+  );
+  ToolbarButton.displayName = "ToolbarButton";
+  var Toolbar = (0, import_react17.memo)((props) => {
+    const classNames = useStyles_default(Toolbar_default);
+    return /* @__PURE__ */ import_react17.default.createElement("div", { className: (0, import_classnames5.default)(classNames["sendbox__toolbar"], props.className) }, props.children);
+  });
+  Toolbar.displayName = "Toolbar";
+  var ToolbarSeparator = (0, import_react17.memo)(
+    (props) => {
+      const classNames = useStyles_default(Toolbar_default);
+      return /* @__PURE__ */ import_react17.default.createElement(
+        "div",
+        {
+          "aria-orientation": "vertical",
+          className: (0, import_classnames5.default)(classNames["sendbox__toolbar-separator"], props.className),
+          role: "separator"
+        }
+      );
+    }
+  );
+  ToolbarSeparator.displayName = "ToolbarSeparator";
+
+  // src/components/sendbox/AddAttachmentButton.module.css
+  var AddAttachmentButton_default = {
+    "sendbox__add-attachment": "AddAttachmentButton_sendbox__add-attachment",
+    "sendbox__add-attachment-input": "AddAttachmentButton_sendbox__add-attachment-input"
+  };
+
+  // src/components/sendbox/AddAttachmentButton.tsx
+  var { useLocalizer: useLocalizer3, useStyleOptions: useStyleOptions2 } = import_botframework_webchat_component4.hooks;
+  function AddAttachmentButton(props) {
+    const inputRef = (0, import_react18.useRef)(null);
+    const classNames = useStyles_default(AddAttachmentButton_default);
+    const localize = useLocalizer3();
+    const [{ uploadAccept, uploadMultiple }] = useStyleOptions2();
+    const onFilesAddedRef = useRefFrom(props.onFilesAdded);
+    const handleClick = (0, import_react18.useCallback)(() => inputRef.current?.click(), [inputRef]);
+    const handleFileChange = (0, import_react18.useCallback)(
+      ({ target: { files } }) => {
+        if (files) {
+          onFilesAddedRef.current?.([...files]);
+          if (inputRef.current) {
+            inputRef.current.value = "";
+          }
+        }
+      },
+      [inputRef, onFilesAddedRef]
+    );
+    return /* @__PURE__ */ import_react18.default.createElement("div", { className: classNames["sendbox__add-attachment"] }, /* @__PURE__ */ import_react18.default.createElement(
+      "input",
+      {
+        accept: uploadAccept,
+        "aria-disabled": props.disabled,
+        "aria-hidden": "true",
+        className: classNames["sendbox__add-attachment-input"],
+        multiple: uploadMultiple,
+        onInput: props.disabled ? void 0 : handleFileChange,
+        readOnly: props.disabled,
+        ref: inputRef,
+        role: "button",
+        tabIndex: -1,
+        type: "file"
+      }
+    ), /* @__PURE__ */ import_react18.default.createElement(
+      ToolbarButton,
+      {
+        "aria-label": localize("TEXT_INPUT_UPLOAD_BUTTON_ALT"),
+        "data-testid": testIds_default.sendBoxUploadButton,
+        onClick: handleClick
+      },
+      /* @__PURE__ */ import_react18.default.createElement(AttachmentIcon, null)
+    ));
+  }
+  var AddAttachmentButton_default2 = (0, import_react18.memo)(AddAttachmentButton);
+
+  // src/components/sendbox/Attachments.tsx
+  var import_botframework_webchat_component5 = __toESM(require_botframework_webchat_component());
+  var import_react19 = __toESM(require_react());
+
+  // src/components/sendbox/Attachments.module.css
+  var Attachments_default = {
+    sendbox__attachment: "Attachments_sendbox__attachment"
+  };
+
+  // src/components/sendbox/Attachments.tsx
+  var { useLocalizer: useLocalizer4 } = import_botframework_webchat_component5.hooks;
+  var attachmentsPluralStringIds = {
+    one: "TEXT_INPUT_ATTACHMENTS_ONE",
+    two: "TEXT_INPUT_ATTACHMENTS_TWO",
+    few: "TEXT_INPUT_ATTACHMENTS_FEW",
+    many: "TEXT_INPUT_ATTACHMENTS_MANY",
+    other: "TEXT_INPUT_ATTACHMENTS_OTHER"
+  };
+  function Attachments({
+    attachments
+  }) {
+    const classNames = useStyles_default(Attachments_default);
+    const localizeWithPlural = useLocalizer4({ plural: true });
+    return attachments.length ? /* @__PURE__ */ import_react19.default.createElement("div", { className: classNames["sendbox__attachment"] }, localizeWithPlural(attachmentsPluralStringIds, attachments.length)) : null;
+  }
+  var Attachments_default2 = (0, import_react19.memo)(Attachments);
+
+  // src/components/sendbox/ErrorMessage.tsx
+  var import_react20 = __toESM(require_react());
+
+  // src/components/sendbox/ErrorMessage.module.css
+  var ErrorMessage_default = {
+    "sendbox__error-message": "ErrorMessage_sendbox__error-message"
+  };
+
+  // src/components/sendbox/ErrorMessage.tsx
+  function ErrorMessage(props) {
+    const classNames = useStyles_default(ErrorMessage_default);
+    return (
+      // eslint-disable-next-line react/forbid-dom-props
+      /* @__PURE__ */ import_react20.default.createElement("span", { className: classNames["sendbox__error-message"], id: props.id, role: "alert" }, props.error)
+    );
+  }
+  var ErrorMessage_default2 = (0, import_react20.memo)(ErrorMessage);
+
+  // src/components/sendbox/TelephoneKeypadToolbarButton.tsx
+  var import_react22 = __toESM(require_react());
+  var import_botframework_webchat_component6 = __toESM(require_botframework_webchat_component());
+
+  // src/icons/TelephoneKeypad.tsx
+  var import_react21 = __toESM(require_react());
+  function TelephoneKeypadIcon(props) {
+    return /* @__PURE__ */ import_react21.default.createElement(
+      "svg",
+      {
+        "aria-hidden": "true",
+        className: props.className,
+        fill: "currentColor",
+        height: "1em",
+        viewBox: "0 0 20 20",
+        width: "1em",
+        xmlns: "http://www.w3.org/2000/svg"
+      },
+      /* @__PURE__ */ import_react21.default.createElement(
+        "path",
+        {
+          d: "M6 5.25a1.25 1.25 0 1 0 0-2.5 1.25 1.25 0 0 0 0 2.5Zm0 4a1.25 1.25 0 1 0 0-2.5 1.25 1.25 0 0 0 0 2.5ZM7.25 12a1.25 1.25 0 1 1-2.5 0 1.25 1.25 0 0 1 2.5 0ZM10 5.25a1.25 1.25 0 1 0 0-2.5 1.25 1.25 0 0 0 0 2.5ZM11.25 8a1.25 1.25 0 1 1-2.5 0 1.25 1.25 0 0 1 2.5 0ZM10 13.25a1.25 1.25 0 1 0 0-2.5 1.25 1.25 0 0 0 0 2.5ZM11.25 16a1.25 1.25 0 1 1-2.5 0 1.25 1.25 0 0 1 2.5 0ZM14 5.25a1.25 1.25 0 1 0 0-2.5 1.25 1.25 0 0 0 0 2.5ZM15.25 8a1.25 1.25 0 1 1-2.5 0 1.25 1.25 0 0 1 2.5 0ZM14 13.25a1.25 1.25 0 1 0 0-2.5 1.25 1.25 0 0 0 0 2.5Z",
+          fill: "currentColor"
+        }
+      )
+    );
+  }
+
+  // src/components/sendbox/TelephoneKeypadToolbarButton.tsx
+  var { useLocalizer: useLocalizer5 } = import_botframework_webchat_component6.hooks;
+  var TelephoneKeypadToolbarButton = (0, import_react22.memo)(() => {
+    const [, setTelephoneKeypadShown] = useShown();
+    const localize = useLocalizer5();
+    const handleClick = (0, import_react22.useCallback)(() => setTelephoneKeypadShown((shown) => !shown), [setTelephoneKeypadShown]);
+    return /* @__PURE__ */ import_react22.default.createElement(
+      ToolbarButton,
+      {
+        "aria-label": localize("TEXT_INPUT_TELEPHONE_KEYPAD_BUTTON_ALT"),
+        "data-testid": testIds_default.sendBoxTelephoneKeypadToolbarButton,
+        onClick: handleClick
+      },
+      /* @__PURE__ */ import_react22.default.createElement(TelephoneKeypadIcon, null)
+    );
+  });
+  TelephoneKeypadToolbarButton.displayName = "SendBox.TelephoneKeypadToolbarButton";
+  var TelephoneKeypadToolbarButton_default = TelephoneKeypadToolbarButton;
+
+  // src/components/sendbox/TextArea.tsx
+  var import_classnames6 = __toESM(require_classnames());
+  var import_react23 = __toESM(require_react());
+
+  // src/components/sendbox/TextArea.module.css
+  var TextArea_default = {
+    "sendbox__text-area": "TextArea_sendbox__text-area",
+    "sendbox__text-area--hidden": "TextArea_sendbox__text-area--hidden",
+    "sendbox__text-area-shared": "TextArea_sendbox__text-area-shared",
+    "sendbox__text-area-doppelganger": "TextArea_sendbox__text-area-doppelganger",
+    "sendbox__text-area-input": "TextArea_sendbox__text-area-input",
+    "sendbox__text-area-input--scroll": "TextArea_sendbox__text-area-input--scroll"
+  };
+
+  // src/components/sendbox/TextArea.tsx
+  var TextArea = (0, import_react23.forwardRef)((props, ref) => {
+    const classNames = useStyles_default(TextArea_default);
+    const handleKeyDown = (0, import_react23.useCallback)((event) => {
+      if (!event.shiftKey && event.key === "Enter") {
+        event.preventDefault();
+        if ("form" in event.target && event.target.form instanceof HTMLFormElement) {
+          event.target?.form?.requestSubmit();
+        }
+      }
+    }, []);
+    return /* @__PURE__ */ import_react23.default.createElement(
+      "div",
+      {
+        className: (0, import_classnames6.default)(
+          classNames["sendbox__text-area"],
+          {
+            [classNames["sendbox__text-area--hidden"]]: props.hidden
+          },
+          props.className
+        ),
+        role: props.hidden ? "hidden" : void 0
+      },
+      /* @__PURE__ */ import_react23.default.createElement(
+        "div",
+        {
+          className: (0, import_classnames6.default)(
+            classNames["sendbox__text-area-doppelganger"],
+            classNames["sendbox__text-area-shared"],
+            classNames["sendbox__text-area-input--scroll"]
+          )
+        },
+        props.value || props.placeholder,
+        " "
+      ),
+      /* @__PURE__ */ import_react23.default.createElement(
+        "textarea",
+        {
+          "aria-label": props["aria-label"],
+          className: (0, import_classnames6.default)(
+            classNames["sendbox__text-area-input"],
+            classNames["sendbox__text-area-shared"],
+            classNames["sendbox__text-area-input--scroll"]
+          ),
+          "data-testid": props["data-testid"],
+          onInput: props.onInput,
+          onKeyDown: handleKeyDown,
+          placeholder: props.placeholder,
+          ref,
+          rows: props.startRows ?? 1,
+          tabIndex: props.hidden ? -1 : void 0,
+          value: props.value
+        }
+      )
+    );
+  });
+  TextArea.displayName = "TextArea";
+  var TextArea_default2 = TextArea;
+
+  // src/components/sendbox/private/useSubmitError.ts
+  var import_botframework_webchat_component7 = __toESM(require_botframework_webchat_component());
+  var import_react24 = __toESM(require_react());
+  var { useConnectivityStatus, useLocalizer: useLocalizer6 } = import_botframework_webchat_component7.hooks;
+  var useSubmitError = ({
+    attachments,
+    message
+  }) => {
+    const [connectivityStatus] = useConnectivityStatus();
+    const localize = useLocalizer6();
+    const submitErrorRef = useRefFrom(
+      connectivityStatus !== "connected" && connectivityStatus !== "reconnected" ? "offline" : !message && !attachments.length ? "empty" : void 0
+    );
+    const errorMessageStringMap = (0, import_react24.useMemo)(
+      () => Object.freeze(
+        (/* @__PURE__ */ new Map()).set("empty", localize("SEND_BOX_IS_EMPTY_TOOLTIP_ALT")).set("offline", localize("CONNECTIVITY_STATUS_ALT_FATAL"))
+      ),
+      [localize]
+    );
+    return (0, import_react24.useMemo)(
+      () => Object.freeze([submitErrorRef, submitErrorRef.current && errorMessageStringMap.get(submitErrorRef.current)]),
+      [errorMessageStringMap, submitErrorRef]
+    );
+  };
+  var useSubmitError_default = useSubmitError;
+
+  // src/components/sendbox/private/useUniqueId.ts
+  var import_react25 = __toESM(require_react());
+  function useUniqueId(prefix) {
+    const id = (0, import_react25.useMemo)(() => Math.random().toString(36).substr(2, 5), []);
+    prefix = prefix ? `${prefix}--` : "";
+    return `${prefix}${id}`;
+  }
+
+  // src/components/sendbox/index.module.css
+  var sendbox_default = {
+    sendbox: "sendbox_sendbox",
+    sendbox__sendbox: "sendbox_sendbox__sendbox",
+    "sendbox__sendbox-text": "sendbox_sendbox__sendbox-text",
+    "sendbox__sendbox-controls": "sendbox_sendbox__sendbox-controls",
+    "sendbox__text-counter": "sendbox_sendbox__text-counter",
+    "sendbox__text-counter--error": "sendbox_sendbox__text-counter--error"
+  };
+
+  // src/components/sendbox/index.tsx
+  var { useStyleOptions: useStyleOptions3, useMakeThumbnail, useLocalizer: useLocalizer7, useSendBoxAttachments, useSendMessage } = import_botframework_webchat_component8.hooks;
+  function SendBox(props) {
+    const inputRef = (0, import_react26.useRef)(null);
+    const [message, setMessage] = (0, import_react26.useState)("");
+    const [attachments, setAttachments] = useSendBoxAttachments();
+    const [{ hideTelephoneKeypadButton, hideUploadButton, maxMessageLength }] = useStyleOptions3();
+    const isMessageLengthExceeded = !!maxMessageLength && message.length > maxMessageLength;
+    const classNames = useStyles_default(sendbox_default);
+    const localize = useLocalizer7();
+    const sendMessage = useSendMessage();
+    const makeThumbnail = useMakeThumbnail();
+    const errorMessageId = useUniqueId("sendbox__error-message-id");
+    const [errorRef, errorMessage] = useSubmitError_default({ message, attachments });
+    const [telephoneKeypadShown] = useShown();
+    const attachmentsRef = useRefFrom(attachments);
+    const messageRef = useRefFrom(message);
+    const handleSendBoxClick = (0, import_react26.useCallback)(
+      (event) => {
+        if ("tabIndex" in event.target && typeof event.target.tabIndex === "number" && event.target.tabIndex >= 0) {
+          return;
+        }
+        inputRef.current?.focus();
+      },
+      [inputRef]
+    );
+    const handleMessageChange = (0, import_react26.useCallback)(
+      (event) => setMessage(event.currentTarget.value),
+      [setMessage]
+    );
+    const handleAddFiles = (0, import_react26.useCallback)(
+      async (inputFiles) => {
+        const newAttachments = Object.freeze(
+          await Promise.all(
+            inputFiles.map(
+              (file) => makeThumbnail(file).then(
+                (thumbnailURL) => Object.freeze({
+                  blob: file,
+                  ...thumbnailURL && { thumbnailURL }
+                })
+              )
+            )
+          )
+        );
+        setAttachments(newAttachments);
+      },
+      [makeThumbnail, setAttachments]
+    );
+    const handleFormSubmit = (0, import_react26.useCallback)(
+      (event) => {
+        event.preventDefault();
+        if (errorRef.current !== "empty" && !isMessageLengthExceeded) {
+          sendMessage(messageRef.current, void 0, { attachments: attachmentsRef.current });
+          setMessage("");
+          setAttachments([]);
+        }
+        inputRef.current?.focus();
+      },
+      [attachmentsRef, messageRef, sendMessage, setAttachments, setMessage, isMessageLengthExceeded, errorRef, inputRef]
+    );
+    const handleTelephoneKeypadButtonClick = (0, import_react26.useCallback)(
+      // TODO: We need more official way of sending DTMF.
+      (dtmf) => sendMessage(`/DTMF ${dtmf}`),
+      [sendMessage]
+    );
+    const aria = {
+      "aria-invalid": "false",
+      ...errorMessage && {
+        "aria-invalid": "true",
+        "aria-errormessage": errorMessageId
+      }
+    };
+    return /* @__PURE__ */ import_react26.default.createElement("form", { ...aria, className: (0, import_classnames7.default)(classNames["sendbox"], props.className), onSubmit: handleFormSubmit }, /* @__PURE__ */ import_react26.default.createElement(SuggestedActions_default, null), /* @__PURE__ */ import_react26.default.createElement("div", { className: (0, import_classnames7.default)(classNames["sendbox__sendbox"]), onClickCapture: handleSendBoxClick }, /* @__PURE__ */ import_react26.default.createElement(
+      Surrogate_default,
+      {
+        autoFocus: true,
+        isHorizontal: false,
+        onButtonClick: handleTelephoneKeypadButtonClick
+      }
+    ), /* @__PURE__ */ import_react26.default.createElement(
+      TextArea_default2,
+      {
+        "aria-label": isMessageLengthExceeded ? localize("TEXT_INPUT_LENGTH_EXCEEDED_ALT") : localize("TEXT_INPUT_ALT"),
+        className: classNames["sendbox__sendbox-text"],
+        "data-testid": testIds_default.sendBoxTextBox,
+        hidden: telephoneKeypadShown,
+        onInput: handleMessageChange,
+        placeholder: props.placeholder ?? localize("TEXT_INPUT_PLACEHOLDER"),
+        ref: inputRef,
+        value: message
+      }
+    ), /* @__PURE__ */ import_react26.default.createElement(Attachments_default2, { attachments }), /* @__PURE__ */ import_react26.default.createElement("div", { className: (0, import_classnames7.default)(classNames["sendbox__sendbox-controls"]) }, maxMessageLength && /* @__PURE__ */ import_react26.default.createElement(
+      "div",
+      {
+        className: (0, import_classnames7.default)(classNames["sendbox__text-counter"], {
+          [classNames["sendbox__text-counter--error"]]: isMessageLengthExceeded
+        })
+      },
+      `${message.length}/${maxMessageLength}`
+    ), /* @__PURE__ */ import_react26.default.createElement(Toolbar, null, !hideTelephoneKeypadButton && /* @__PURE__ */ import_react26.default.createElement(TelephoneKeypadToolbarButton_default, null), !hideUploadButton && /* @__PURE__ */ import_react26.default.createElement(AddAttachmentButton_default2, { onFilesAdded: handleAddFiles }), /* @__PURE__ */ import_react26.default.createElement(ToolbarSeparator, null), /* @__PURE__ */ import_react26.default.createElement(
+      ToolbarButton,
+      {
+        "aria-label": localize("TEXT_INPUT_SEND_BUTTON_ALT"),
+        "data-testid": testIds_default.sendBoxSendButton,
+        disabled: isMessageLengthExceeded,
+        type: "submit"
+      },
+      /* @__PURE__ */ import_react26.default.createElement(SendIcon, null)
+    ))), /* @__PURE__ */ import_react26.default.createElement(DropZone_default, { onFilesAdded: handleAddFiles }), /* @__PURE__ */ import_react26.default.createElement(ErrorMessage_default2, { error: errorMessage, id: errorMessageId })));
+  }
+  var sendbox_default2 = (0, import_react26.memo)(SendBox);
+
+  // src/components/SendBox.tsx
+  var SendBox_default = sendbox_default2;
+
+  // src/private/FluentThemeProvider.tsx
+  var { ThemeProvider } = import_botframework_webchat_component9.Components;
+  var sendBoxMiddleware = [() => () => () => SendBox_default];
+  var FluentThemeProvider = ({ children }) => /* @__PURE__ */ import_react27.default.createElement(WebchatTheme, null, /* @__PURE__ */ import_react27.default.createElement(Provider_default, null, /* @__PURE__ */ import_react27.default.createElement(ThemeProvider, { sendBoxMiddleware }, children)));
+  var FluentThemeProvider_default = (0, import_react27.memo)(FluentThemeProvider);
+
+  // src/index.ts
+  injectMeta("botframework-webchat-fluent-theme:version", "4.17.0-main.20240416.4ff01ae");
+  injectStyles();
+
+  // src/bundle.ts
+  globalThis.WebChat = {
+    ...globalThis.WebChat,
+    FluentThemeProvider: FluentThemeProvider_default,
+    testIds: {
+      ...globalThis.WebChat?.testIds,
+      ...testIds_default
+    }
+  };
+})();
+/*! Bundled license information:
+
+classnames/index.js:
+  (*!
+  	Copyright (c) 2018 Jed Watson.
+  	Licensed under the MIT License (MIT), see
+  	http://jedwatson.github.io/classnames
+  *)
+*/
+//# sourceMappingURL=botframework-webchat-fluent-theme.development.js.map