@ahana-awesome-platform/ahana-electron-sdk 1.0.0

package/dist/esm/controller/index.js

@@ -0,0 +1,1128 @@
+import { ipcMain } from "electron";
+import { c as commonjsGlobal } from "../_commonjsHelpers-Dm6U3U_N.js";
+/*! *****************************************************************************
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+var Reflect$1;
+(function(Reflect2) {
+  (function(factory) {
+    var root = typeof globalThis === "object" ? globalThis : typeof commonjsGlobal === "object" ? commonjsGlobal : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+    var exporter = makeExporter(Reflect2);
+    if (typeof root.Reflect !== "undefined") {
+      exporter = makeExporter(root.Reflect, exporter);
+    }
+    factory(exporter, root);
+    if (typeof root.Reflect === "undefined") {
+      root.Reflect = Reflect2;
+    }
+    function makeExporter(target, previous) {
+      return function(key, value) {
+        Object.defineProperty(target, key, { configurable: true, writable: true, value });
+        if (previous)
+          previous(key, value);
+      };
+    }
+    function functionThis() {
+      try {
+        return Function("return this;")();
+      } catch (_) {
+      }
+    }
+    function indirectEvalThis() {
+      try {
+        return (void 0, eval)("(function() { return this; })()");
+      } catch (_) {
+      }
+    }
+    function sloppyModeThis() {
+      return functionThis() || indirectEvalThis();
+    }
+  })(function(exporter, root) {
+    var hasOwn = Object.prototype.hasOwnProperty;
+    var supportsSymbol = typeof Symbol === "function";
+    var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+    var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+    var supportsCreate = typeof Object.create === "function";
+    var supportsProto = { __proto__: [] } instanceof Array;
+    var downLevel = !supportsCreate && !supportsProto;
+    var HashMap = {
+      // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+      create: supportsCreate ? function() {
+        return MakeDictionary(/* @__PURE__ */ Object.create(null));
+      } : supportsProto ? function() {
+        return MakeDictionary({ __proto__: null });
+      } : function() {
+        return MakeDictionary({});
+      },
+      has: downLevel ? function(map, key) {
+        return hasOwn.call(map, key);
+      } : function(map, key) {
+        return key in map;
+      },
+      get: downLevel ? function(map, key) {
+        return hasOwn.call(map, key) ? map[key] : void 0;
+      } : function(map, key) {
+        return map[key];
+      }
+    };
+    var functionPrototype = Object.getPrototypeOf(Function);
+    var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+    var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+    var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+    var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
+    var metadataRegistry = GetOrCreateMetadataRegistry();
+    var metadataProvider = CreateMetadataProvider(metadataRegistry);
+    function decorate(decorators, target, propertyKey, attributes) {
+      if (!IsUndefined(propertyKey)) {
+        if (!IsArray(decorators))
+          throw new TypeError();
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+          throw new TypeError();
+        if (IsNull(attributes))
+          attributes = void 0;
+        propertyKey = ToPropertyKey(propertyKey);
+        return DecorateProperty(decorators, target, propertyKey, attributes);
+      } else {
+        if (!IsArray(decorators))
+          throw new TypeError();
+        if (!IsConstructor(target))
+          throw new TypeError();
+        return DecorateConstructor(decorators, target);
+      }
+    }
+    exporter("decorate", decorate);
+    function metadata(metadataKey, metadataValue) {
+      function decorator(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+          throw new TypeError();
+        OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+      }
+      return decorator;
+    }
+    exporter("metadata", metadata);
+    function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+    }
+    exporter("defineMetadata", defineMetadata);
+    function hasMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("hasMetadata", hasMetadata);
+    function hasOwnMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("hasOwnMetadata", hasOwnMetadata);
+    function getMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("getMetadata", getMetadata);
+    function getOwnMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("getOwnMetadata", getOwnMetadata);
+    function getMetadataKeys(target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryMetadataKeys(target, propertyKey);
+    }
+    exporter("getMetadataKeys", getMetadataKeys);
+    function getOwnMetadataKeys(target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryOwnMetadataKeys(target, propertyKey);
+    }
+    exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+    function deleteMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      var provider = GetMetadataProvider(
+        target,
+        propertyKey,
+        /*Create*/
+        false
+      );
+      if (IsUndefined(provider))
+        return false;
+      return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("deleteMetadata", deleteMetadata);
+    function DecorateConstructor(decorators, target) {
+      for (var i = decorators.length - 1; i >= 0; --i) {
+        var decorator = decorators[i];
+        var decorated = decorator(target);
+        if (!IsUndefined(decorated) && !IsNull(decorated)) {
+          if (!IsConstructor(decorated))
+            throw new TypeError();
+          target = decorated;
+        }
+      }
+      return target;
+    }
+    function DecorateProperty(decorators, target, propertyKey, descriptor) {
+      for (var i = decorators.length - 1; i >= 0; --i) {
+        var decorator = decorators[i];
+        var decorated = decorator(target, propertyKey, descriptor);
+        if (!IsUndefined(decorated) && !IsNull(decorated)) {
+          if (!IsObject(decorated))
+            throw new TypeError();
+          descriptor = decorated;
+        }
+      }
+      return descriptor;
+    }
+    function OrdinaryHasMetadata(MetadataKey, O, P) {
+      var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+      if (hasOwn2)
+        return true;
+      var parent = OrdinaryGetPrototypeOf(O);
+      if (!IsNull(parent))
+        return OrdinaryHasMetadata(MetadataKey, parent, P);
+      return false;
+    }
+    function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+      var provider = GetMetadataProvider(
+        O,
+        P,
+        /*Create*/
+        false
+      );
+      if (IsUndefined(provider))
+        return false;
+      return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+    }
+    function OrdinaryGetMetadata(MetadataKey, O, P) {
+      var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+      if (hasOwn2)
+        return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+      var parent = OrdinaryGetPrototypeOf(O);
+      if (!IsNull(parent))
+        return OrdinaryGetMetadata(MetadataKey, parent, P);
+      return void 0;
+    }
+    function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+      var provider = GetMetadataProvider(
+        O,
+        P,
+        /*Create*/
+        false
+      );
+      if (IsUndefined(provider))
+        return;
+      return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+    }
+    function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+      var provider = GetMetadataProvider(
+        O,
+        P,
+        /*Create*/
+        true
+      );
+      provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+    }
+    function OrdinaryMetadataKeys(O, P) {
+      var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+      var parent = OrdinaryGetPrototypeOf(O);
+      if (parent === null)
+        return ownKeys;
+      var parentKeys = OrdinaryMetadataKeys(parent, P);
+      if (parentKeys.length <= 0)
+        return ownKeys;
+      if (ownKeys.length <= 0)
+        return parentKeys;
+      var set = new _Set();
+      var keys = [];
+      for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
+        var key = ownKeys_1[_i];
+        var hasKey = set.has(key);
+        if (!hasKey) {
+          set.add(key);
+          keys.push(key);
+        }
+      }
+      for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
+        var key = parentKeys_1[_a];
+        var hasKey = set.has(key);
+        if (!hasKey) {
+          set.add(key);
+          keys.push(key);
+        }
+      }
+      return keys;
+    }
+    function OrdinaryOwnMetadataKeys(O, P) {
+      var provider = GetMetadataProvider(
+        O,
+        P,
+        /*create*/
+        false
+      );
+      if (!provider) {
+        return [];
+      }
+      return provider.OrdinaryOwnMetadataKeys(O, P);
+    }
+    function Type(x) {
+      if (x === null)
+        return 1;
+      switch (typeof x) {
+        case "undefined":
+          return 0;
+        case "boolean":
+          return 2;
+        case "string":
+          return 3;
+        case "symbol":
+          return 4;
+        case "number":
+          return 5;
+        case "object":
+          return x === null ? 1 : 6;
+        default:
+          return 6;
+      }
+    }
+    function IsUndefined(x) {
+      return x === void 0;
+    }
+    function IsNull(x) {
+      return x === null;
+    }
+    function IsSymbol(x) {
+      return typeof x === "symbol";
+    }
+    function IsObject(x) {
+      return typeof x === "object" ? x !== null : typeof x === "function";
+    }
+    function ToPrimitive(input, PreferredType) {
+      switch (Type(input)) {
+        case 0:
+          return input;
+        case 1:
+          return input;
+        case 2:
+          return input;
+        case 3:
+          return input;
+        case 4:
+          return input;
+        case 5:
+          return input;
+      }
+      var hint = "string";
+      var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+      if (exoticToPrim !== void 0) {
+        var result = exoticToPrim.call(input, hint);
+        if (IsObject(result))
+          throw new TypeError();
+        return result;
+      }
+      return OrdinaryToPrimitive(input);
+    }
+    function OrdinaryToPrimitive(O, hint) {
+      var valueOf, result, toString_2;
+      {
+        var toString_1 = O.toString;
+        if (IsCallable(toString_1)) {
+          var result = toString_1.call(O);
+          if (!IsObject(result))
+            return result;
+        }
+        var valueOf = O.valueOf;
+        if (IsCallable(valueOf)) {
+          var result = valueOf.call(O);
+          if (!IsObject(result))
+            return result;
+        }
+      }
+      throw new TypeError();
+    }
+    function ToBoolean(argument) {
+      return !!argument;
+    }
+    function ToString(argument) {
+      return "" + argument;
+    }
+    function ToPropertyKey(argument) {
+      var key = ToPrimitive(argument);
+      if (IsSymbol(key))
+        return key;
+      return ToString(key);
+    }
+    function IsArray(argument) {
+      return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+    }
+    function IsCallable(argument) {
+      return typeof argument === "function";
+    }
+    function IsConstructor(argument) {
+      return typeof argument === "function";
+    }
+    function IsPropertyKey(argument) {
+      switch (Type(argument)) {
+        case 3:
+          return true;
+        case 4:
+          return true;
+        default:
+          return false;
+      }
+    }
+    function SameValueZero(x, y) {
+      return x === y || x !== x && y !== y;
+    }
+    function GetMethod(V, P) {
+      var func = V[P];
+      if (func === void 0 || func === null)
+        return void 0;
+      if (!IsCallable(func))
+        throw new TypeError();
+      return func;
+    }
+    function GetIterator(obj) {
+      var method = GetMethod(obj, iteratorSymbol);
+      if (!IsCallable(method))
+        throw new TypeError();
+      var iterator = method.call(obj);
+      if (!IsObject(iterator))
+        throw new TypeError();
+      return iterator;
+    }
+    function IteratorValue(iterResult) {
+      return iterResult.value;
+    }
+    function IteratorStep(iterator) {
+      var result = iterator.next();
+      return result.done ? false : result;
+    }
+    function IteratorClose(iterator) {
+      var f = iterator["return"];
+      if (f)
+        f.call(iterator);
+    }
+    function OrdinaryGetPrototypeOf(O) {
+      var proto = Object.getPrototypeOf(O);
+      if (typeof O !== "function" || O === functionPrototype)
+        return proto;
+      if (proto !== functionPrototype)
+        return proto;
+      var prototype = O.prototype;
+      var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+      if (prototypeProto == null || prototypeProto === Object.prototype)
+        return proto;
+      var constructor = prototypeProto.constructor;
+      if (typeof constructor !== "function")
+        return proto;
+      if (constructor === O)
+        return proto;
+      return constructor;
+    }
+    function CreateMetadataRegistry() {
+      var fallback;
+      if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+        fallback = CreateFallbackProvider(root.Reflect);
+      }
+      var first;
+      var second;
+      var rest;
+      var targetProviderMap = new _WeakMap();
+      var registry = {
+        registerProvider,
+        getProvider,
+        setProvider
+      };
+      return registry;
+      function registerProvider(provider) {
+        if (!Object.isExtensible(registry)) {
+          throw new Error("Cannot add provider to a frozen registry.");
+        }
+        switch (true) {
+          case fallback === provider:
+            break;
+          case IsUndefined(first):
+            first = provider;
+            break;
+          case first === provider:
+            break;
+          case IsUndefined(second):
+            second = provider;
+            break;
+          case second === provider:
+            break;
+          default:
+            if (rest === void 0)
+              rest = new _Set();
+            rest.add(provider);
+            break;
+        }
+      }
+      function getProviderNoCache(O, P) {
+        if (!IsUndefined(first)) {
+          if (first.isProviderFor(O, P))
+            return first;
+          if (!IsUndefined(second)) {
+            if (second.isProviderFor(O, P))
+              return first;
+            if (!IsUndefined(rest)) {
+              var iterator = GetIterator(rest);
+              while (true) {
+                var next = IteratorStep(iterator);
+                if (!next) {
+                  return void 0;
+                }
+                var provider = IteratorValue(next);
+                if (provider.isProviderFor(O, P)) {
+                  IteratorClose(iterator);
+                  return provider;
+                }
+              }
+            }
+          }
+        }
+        if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+          return fallback;
+        }
+        return void 0;
+      }
+      function getProvider(O, P) {
+        var providerMap = targetProviderMap.get(O);
+        var provider;
+        if (!IsUndefined(providerMap)) {
+          provider = providerMap.get(P);
+        }
+        if (!IsUndefined(provider)) {
+          return provider;
+        }
+        provider = getProviderNoCache(O, P);
+        if (!IsUndefined(provider)) {
+          if (IsUndefined(providerMap)) {
+            providerMap = new _Map();
+            targetProviderMap.set(O, providerMap);
+          }
+          providerMap.set(P, provider);
+        }
+        return provider;
+      }
+      function hasProvider(provider) {
+        if (IsUndefined(provider))
+          throw new TypeError();
+        return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+      }
+      function setProvider(O, P, provider) {
+        if (!hasProvider(provider)) {
+          throw new Error("Metadata provider not registered.");
+        }
+        var existingProvider = getProvider(O, P);
+        if (existingProvider !== provider) {
+          if (!IsUndefined(existingProvider)) {
+            return false;
+          }
+          var providerMap = targetProviderMap.get(O);
+          if (IsUndefined(providerMap)) {
+            providerMap = new _Map();
+            targetProviderMap.set(O, providerMap);
+          }
+          providerMap.set(P, provider);
+        }
+        return true;
+      }
+    }
+    function GetOrCreateMetadataRegistry() {
+      var metadataRegistry2;
+      if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+        metadataRegistry2 = root.Reflect[registrySymbol];
+      }
+      if (IsUndefined(metadataRegistry2)) {
+        metadataRegistry2 = CreateMetadataRegistry();
+      }
+      if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+        Object.defineProperty(root.Reflect, registrySymbol, {
+          enumerable: false,
+          configurable: false,
+          writable: false,
+          value: metadataRegistry2
+        });
+      }
+      return metadataRegistry2;
+    }
+    function CreateMetadataProvider(registry) {
+      var metadata2 = new _WeakMap();
+      var provider = {
+        isProviderFor: function(O, P) {
+          var targetMetadata = metadata2.get(O);
+          if (IsUndefined(targetMetadata))
+            return false;
+          return targetMetadata.has(P);
+        },
+        OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+        OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+        OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+        OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+        OrdinaryDeleteMetadata
+      };
+      metadataRegistry.registerProvider(provider);
+      return provider;
+      function GetOrCreateMetadataMap(O, P, Create) {
+        var targetMetadata = metadata2.get(O);
+        var createdTargetMetadata = false;
+        if (IsUndefined(targetMetadata)) {
+          if (!Create)
+            return void 0;
+          targetMetadata = new _Map();
+          metadata2.set(O, targetMetadata);
+          createdTargetMetadata = true;
+        }
+        var metadataMap = targetMetadata.get(P);
+        if (IsUndefined(metadataMap)) {
+          if (!Create)
+            return void 0;
+          metadataMap = new _Map();
+          targetMetadata.set(P, metadataMap);
+          if (!registry.setProvider(O, P, provider)) {
+            targetMetadata.delete(P);
+            if (createdTargetMetadata) {
+              metadata2.delete(O);
+            }
+            throw new Error("Wrong provider for target.");
+          }
+        }
+        return metadataMap;
+      }
+      function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(metadataMap))
+          return false;
+        return ToBoolean(metadataMap.has(MetadataKey));
+      }
+      function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(metadataMap))
+          return void 0;
+        return metadataMap.get(MetadataKey);
+      }
+      function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          true
+        );
+        metadataMap.set(MetadataKey, MetadataValue);
+      }
+      function OrdinaryOwnMetadataKeys2(O, P) {
+        var keys = [];
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(metadataMap))
+          return keys;
+        var keysObj = metadataMap.keys();
+        var iterator = GetIterator(keysObj);
+        var k = 0;
+        while (true) {
+          var next = IteratorStep(iterator);
+          if (!next) {
+            keys.length = k;
+            return keys;
+          }
+          var nextValue = IteratorValue(next);
+          try {
+            keys[k] = nextValue;
+          } catch (e) {
+            try {
+              IteratorClose(iterator);
+            } finally {
+              throw e;
+            }
+          }
+          k++;
+        }
+      }
+      function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(metadataMap))
+          return false;
+        if (!metadataMap.delete(MetadataKey))
+          return false;
+        if (metadataMap.size === 0) {
+          var targetMetadata = metadata2.get(O);
+          if (!IsUndefined(targetMetadata)) {
+            targetMetadata.delete(P);
+            if (targetMetadata.size === 0) {
+              metadata2.delete(targetMetadata);
+            }
+          }
+        }
+        return true;
+      }
+    }
+    function CreateFallbackProvider(reflect) {
+      var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
+      var metadataOwner = new _WeakMap();
+      var provider = {
+        isProviderFor: function(O, P) {
+          var metadataPropertySet = metadataOwner.get(O);
+          if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+            return true;
+          }
+          if (getOwnMetadataKeys2(O, P).length) {
+            if (IsUndefined(metadataPropertySet)) {
+              metadataPropertySet = new _Set();
+              metadataOwner.set(O, metadataPropertySet);
+            }
+            metadataPropertySet.add(P);
+            return true;
+          }
+          return false;
+        },
+        OrdinaryDefineOwnMetadata: defineMetadata2,
+        OrdinaryHasOwnMetadata: hasOwnMetadata2,
+        OrdinaryGetOwnMetadata: getOwnMetadata2,
+        OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+        OrdinaryDeleteMetadata: deleteMetadata2
+      };
+      return provider;
+    }
+    function GetMetadataProvider(O, P, Create) {
+      var registeredProvider = metadataRegistry.getProvider(O, P);
+      if (!IsUndefined(registeredProvider)) {
+        return registeredProvider;
+      }
+      if (Create) {
+        if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+          return metadataProvider;
+        }
+        throw new Error("Illegal state.");
+      }
+      return void 0;
+    }
+    function CreateMapPolyfill() {
+      var cacheSentinel = {};
+      var arraySentinel = [];
+      var MapIterator = (
+        /** @class */
+        function() {
+          function MapIterator2(keys, values, selector) {
+            this._index = 0;
+            this._keys = keys;
+            this._values = values;
+            this._selector = selector;
+          }
+          MapIterator2.prototype["@@iterator"] = function() {
+            return this;
+          };
+          MapIterator2.prototype[iteratorSymbol] = function() {
+            return this;
+          };
+          MapIterator2.prototype.next = function() {
+            var index = this._index;
+            if (index >= 0 && index < this._keys.length) {
+              var result = this._selector(this._keys[index], this._values[index]);
+              if (index + 1 >= this._keys.length) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              } else {
+                this._index++;
+              }
+              return { value: result, done: false };
+            }
+            return { value: void 0, done: true };
+          };
+          MapIterator2.prototype.throw = function(error) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            throw error;
+          };
+          MapIterator2.prototype.return = function(value) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            return { value, done: true };
+          };
+          return MapIterator2;
+        }()
+      );
+      var Map2 = (
+        /** @class */
+        function() {
+          function Map3() {
+            this._keys = [];
+            this._values = [];
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          }
+          Object.defineProperty(Map3.prototype, "size", {
+            get: function() {
+              return this._keys.length;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Map3.prototype.has = function(key) {
+            return this._find(
+              key,
+              /*insert*/
+              false
+            ) >= 0;
+          };
+          Map3.prototype.get = function(key) {
+            var index = this._find(
+              key,
+              /*insert*/
+              false
+            );
+            return index >= 0 ? this._values[index] : void 0;
+          };
+          Map3.prototype.set = function(key, value) {
+            var index = this._find(
+              key,
+              /*insert*/
+              true
+            );
+            this._values[index] = value;
+            return this;
+          };
+          Map3.prototype.delete = function(key) {
+            var index = this._find(
+              key,
+              /*insert*/
+              false
+            );
+            if (index >= 0) {
+              var size = this._keys.length;
+              for (var i = index + 1; i < size; i++) {
+                this._keys[i - 1] = this._keys[i];
+                this._values[i - 1] = this._values[i];
+              }
+              this._keys.length--;
+              this._values.length--;
+              if (SameValueZero(key, this._cacheKey)) {
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              return true;
+            }
+            return false;
+          };
+          Map3.prototype.clear = function() {
+            this._keys.length = 0;
+            this._values.length = 0;
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          };
+          Map3.prototype.keys = function() {
+            return new MapIterator(this._keys, this._values, getKey);
+          };
+          Map3.prototype.values = function() {
+            return new MapIterator(this._keys, this._values, getValue);
+          };
+          Map3.prototype.entries = function() {
+            return new MapIterator(this._keys, this._values, getEntry);
+          };
+          Map3.prototype["@@iterator"] = function() {
+            return this.entries();
+          };
+          Map3.prototype[iteratorSymbol] = function() {
+            return this.entries();
+          };
+          Map3.prototype._find = function(key, insert) {
+            if (!SameValueZero(this._cacheKey, key)) {
+              this._cacheIndex = -1;
+              for (var i = 0; i < this._keys.length; i++) {
+                if (SameValueZero(this._keys[i], key)) {
+                  this._cacheIndex = i;
+                  break;
+                }
+              }
+            }
+            if (this._cacheIndex < 0 && insert) {
+              this._cacheIndex = this._keys.length;
+              this._keys.push(key);
+              this._values.push(void 0);
+            }
+            return this._cacheIndex;
+          };
+          return Map3;
+        }()
+      );
+      return Map2;
+      function getKey(key, _) {
+        return key;
+      }
+      function getValue(_, value) {
+        return value;
+      }
+      function getEntry(key, value) {
+        return [key, value];
+      }
+    }
+    function CreateSetPolyfill() {
+      var Set2 = (
+        /** @class */
+        function() {
+          function Set3() {
+            this._map = new _Map();
+          }
+          Object.defineProperty(Set3.prototype, "size", {
+            get: function() {
+              return this._map.size;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Set3.prototype.has = function(value) {
+            return this._map.has(value);
+          };
+          Set3.prototype.add = function(value) {
+            return this._map.set(value, value), this;
+          };
+          Set3.prototype.delete = function(value) {
+            return this._map.delete(value);
+          };
+          Set3.prototype.clear = function() {
+            this._map.clear();
+          };
+          Set3.prototype.keys = function() {
+            return this._map.keys();
+          };
+          Set3.prototype.values = function() {
+            return this._map.keys();
+          };
+          Set3.prototype.entries = function() {
+            return this._map.entries();
+          };
+          Set3.prototype["@@iterator"] = function() {
+            return this.keys();
+          };
+          Set3.prototype[iteratorSymbol] = function() {
+            return this.keys();
+          };
+          return Set3;
+        }()
+      );
+      return Set2;
+    }
+    function CreateWeakMapPolyfill() {
+      var UUID_SIZE = 16;
+      var keys = HashMap.create();
+      var rootKey = CreateUniqueKey();
+      return (
+        /** @class */
+        function() {
+          function WeakMap2() {
+            this._key = CreateUniqueKey();
+          }
+          WeakMap2.prototype.has = function(target) {
+            var table = GetOrCreateWeakMapTable(
+              target,
+              /*create*/
+              false
+            );
+            return table !== void 0 ? HashMap.has(table, this._key) : false;
+          };
+          WeakMap2.prototype.get = function(target) {
+            var table = GetOrCreateWeakMapTable(
+              target,
+              /*create*/
+              false
+            );
+            return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+          };
+          WeakMap2.prototype.set = function(target, value) {
+            var table = GetOrCreateWeakMapTable(
+              target,
+              /*create*/
+              true
+            );
+            table[this._key] = value;
+            return this;
+          };
+          WeakMap2.prototype.delete = function(target) {
+            var table = GetOrCreateWeakMapTable(
+              target,
+              /*create*/
+              false
+            );
+            return table !== void 0 ? delete table[this._key] : false;
+          };
+          WeakMap2.prototype.clear = function() {
+            this._key = CreateUniqueKey();
+          };
+          return WeakMap2;
+        }()
+      );
+      function CreateUniqueKey() {
+        var key;
+        do
+          key = "@@WeakMap@@" + CreateUUID();
+        while (HashMap.has(keys, key));
+        keys[key] = true;
+        return key;
+      }
+      function GetOrCreateWeakMapTable(target, create) {
+        if (!hasOwn.call(target, rootKey)) {
+          if (!create)
+            return void 0;
+          Object.defineProperty(target, rootKey, { value: HashMap.create() });
+        }
+        return target[rootKey];
+      }
+      function FillRandomBytes(buffer, size) {
+        for (var i = 0; i < size; ++i)
+          buffer[i] = Math.random() * 255 | 0;
+        return buffer;
+      }
+      function GenRandomBytes(size) {
+        if (typeof Uint8Array === "function") {
+          var array = new Uint8Array(size);
+          if (typeof crypto !== "undefined") {
+            crypto.getRandomValues(array);
+          } else if (typeof msCrypto !== "undefined") {
+            msCrypto.getRandomValues(array);
+          } else {
+            FillRandomBytes(array, size);
+          }
+          return array;
+        }
+        return FillRandomBytes(new Array(size), size);
+      }
+      function CreateUUID() {
+        var data = GenRandomBytes(UUID_SIZE);
+        data[6] = data[6] & 79 | 64;
+        data[8] = data[8] & 191 | 128;
+        var result = "";
+        for (var offset = 0; offset < UUID_SIZE; ++offset) {
+          var byte = data[offset];
+          if (offset === 4 || offset === 6 || offset === 8)
+            result += "-";
+          if (byte < 16)
+            result += "0";
+          result += byte.toString(16).toLowerCase();
+        }
+        return result;
+      }
+    }
+    function MakeDictionary(obj) {
+      obj.__ = void 0;
+      delete obj.__;
+      return obj;
+    }
+  });
+})(Reflect$1 || (Reflect$1 = {}));
+const IPC_ROUTES_KEY = Symbol("ipc:routes");
+const PREFIX_KEY = Symbol("ipc:prefix");
+const getIpcRoutes = (target) => {
+  const routes = Reflect.getMetadata(IPC_ROUTES_KEY, target);
+  return routes || [];
+};
+const createBoundHandler = (handler, instance) => async (event, ...args) => {
+  try {
+    return await handler.call(instance, event, ...args);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw errorMessage;
+  }
+};
+const RestController = (prefix = "") => (target) => {
+  const constructor = target;
+  Reflect.defineMetadata(PREFIX_KEY, prefix, constructor);
+  const routes = getIpcRoutes(constructor.prototype);
+  if (routes.length === 0) {
+    `控制器 ${constructor.name || "未知"} 没有IPC路由`;
+    return;
+  }
+  const instance = new constructor();
+  for (const route of routes) {
+    const { channel, handler } = route;
+    const fullChannel = prefix ? `${prefix}:${channel}` : channel;
+    const boundHandler = createBoundHandler(handler, instance);
+    ipcMain.handle(fullChannel, boundHandler);
+  }
+  Reflect.deleteMetadata(IPC_ROUTES_KEY, constructor.prototype);
+};
+const RequestMapping = (channel) => (target, propertyKey, descriptor) => {
+  if (!descriptor || !descriptor.value) {
+    throw new Error("缺少方法描述符");
+  }
+  if (typeof descriptor.value !== "function") {
+    throw new Error("目标必须是函数");
+  }
+  const routes = getIpcRoutes(target);
+  routes.push({
+    channel,
+    handler: descriptor.value
+  });
+  Reflect.defineMetadata(IPC_ROUTES_KEY, routes, target);
+};
+export {
+  RequestMapping,
+  RestController
+};