wowok 1.8.2 → 2.1.9

package/dist/cjs/w/messenger/types.js

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var types_exports = {};
+__export(types_exports, {
+  CHAIN_PROOF_TYPE: () => CHAIN_PROOF_TYPE,
+  CURRENT_NETWORK: () => CURRENT_NETWORK,
+  DEFAULT_DEVICE_ID: () => DEFAULT_DEVICE_ID,
+  DEFAULT_MESSENGER_CONFIG: () => DEFAULT_MESSENGER_CONFIG,
+  DEFAULT_QUERY_LIMIT: () => DEFAULT_QUERY_LIMIT,
+  MAX_QUERY_LIMIT: () => MAX_QUERY_LIMIT,
+  MessageDirection: () => MessageDirection,
+  MessageStatus: () => MessageStatus,
+  MessageType: () => MessageType,
+  MessengerError: () => MessengerError,
+  MessengerErrorCode: () => MessengerErrorCode,
+  NORMAL_MESSAGE_BYTES_LIMIT: () => NORMAL_MESSAGE_BYTES_LIMIT,
+  SERVER_URL: () => SERVER_URL,
+  WTS_FILE_BYTES_LIMIT: () => WTS_FILE_BYTES_LIMIT,
+  WTS_MAX_MESSAGE_COUNT: () => WTS_MAX_MESSAGE_COUNT
+});
+module.exports = __toCommonJS(types_exports);
+var import_network = require("../../client/network.js");
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2[MessageType2["PREKEY_MESSAGE"] = 3] = "PREKEY_MESSAGE";
+  MessageType2[MessageType2["NORMAL_MESSAGE"] = 1] = "NORMAL_MESSAGE";
+  return MessageType2;
+})(MessageType || {});
+var MessageDirection = /* @__PURE__ */ ((MessageDirection2) => {
+  MessageDirection2["SENT"] = "sent";
+  MessageDirection2["RECEIVED"] = "received";
+  return MessageDirection2;
+})(MessageDirection || {});
+var MessageStatus = /* @__PURE__ */ ((MessageStatus2) => {
+  MessageStatus2["PENDING"] = "pending";
+  MessageStatus2["CONFIRMED"] = "confirmed";
+  MessageStatus2["READ"] = "read";
+  MessageStatus2["FAILED"] = "failed";
+  MessageStatus2["REJECTED"] = "rejected";
+  return MessageStatus2;
+})(MessageStatus || {});
+const WTS_FILE_BYTES_LIMIT = 5 * 1024 * 1024;
+const WTS_MAX_MESSAGE_COUNT = 1e3;
+const NORMAL_MESSAGE_BYTES_LIMIT = 10 * 1024;
+const DEFAULT_QUERY_LIMIT = 50;
+const MAX_QUERY_LIMIT = 1e3;
+const DEFAULT_DEVICE_ID = 1;
+const SERVER_URL = "https://messenger.wowok.net";
+const CHAIN_PROOF_TYPE = 1;
+const CURRENT_NETWORK = import_network.ENTRYPOINT.Testnet;
+const DEFAULT_MESSENGER_CONFIG = {
+  prekey_count: 40,
+  watch_interval_ms: 60 * 1e3,
+  // 1分钟
+  serverUrl: SERVER_URL,
+  network: CURRENT_NETWORK,
+  // 默认每天检查一次预密钥状态
+  prekeyCheckIntervalMs: 24 * 60 * 60 * 1e3,
+  // 1天
+  // 查询限制默认值
+  defaultQueryLimit: DEFAULT_QUERY_LIMIT
+  // 50
+};
+var MessengerErrorCode = /* @__PURE__ */ ((MessengerErrorCode2) => {
+  MessengerErrorCode2["PREKEYS_FULL"] = "PREKEYS_FULL";
+  MessengerErrorCode2["ACCOUNT_NOT_FOUND"] = "ACCOUNT_NOT_FOUND";
+  MessengerErrorCode2["IDENTITY_NOT_FOUND"] = "IDENTITY_NOT_FOUND";
+  MessengerErrorCode2["IDENTITY_CONFLICT"] = "IDENTITY_CONFLICT";
+  MessengerErrorCode2["SESSION_NOT_ESTABLISHED"] = "SESSION_NOT_ESTABLISHED";
+  MessengerErrorCode2["ENCRYPTION_FAILED"] = "ENCRYPTION_FAILED";
+  MessengerErrorCode2["DECRYPTION_FAILED"] = "DECRYPTION_FAILED";
+  MessengerErrorCode2["SERVER_ERROR"] = "SERVER_ERROR";
+  MessengerErrorCode2["INVALID_PROOF"] = "INVALID_PROOF";
+  MessengerErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  MessengerErrorCode2["INVALID_INPUT"] = "INVALID_INPUT";
+  MessengerErrorCode2["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
+  MessengerErrorCode2["INVALID_MESSAGE_TYPE"] = "INVALID_MESSAGE_TYPE";
+  MessengerErrorCode2["MESSAGE_NOT_DECRYPTED"] = "MESSAGE_NOT_DECRYPTED";
+  MessengerErrorCode2["HASH_MISMATCH"] = "HASH_MISMATCH";
+  MessengerErrorCode2["ACCOUNT_MESSENGER_NOT_ENABLED"] = "ACCOUNT_MESSENGER_NOT_ENABLED";
+  return MessengerErrorCode2;
+})(MessengerErrorCode || {});
+class MessengerError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    __publicField(this, "code", code);
+    __publicField(this, "cause", cause);
+    this.name = "MessengerError";
+  }
+}

package/dist/cjs/w/messenger/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * JSON 工具函数
+ *
+ * 提供 JSON 序列化和规范化功能
+ */
+/**
+ * 规范化 JSON 对象（按键名排序）
+ *
+ * 用于生成确定性的 JSON 字符串，确保相同内容的对象
+ * 无论属性顺序如何，都能生成相同的字符串。
+ *
+ * @param obj 要规范化的对象
+ * @returns 规范化后的 JSON 字符串
+ */
+export declare function canonicalizeJson(obj: unknown): string;

package/dist/cjs/w/messenger/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  canonicalizeJson: () => canonicalizeJson
+});
+module.exports = __toCommonJS(utils_exports);
+function canonicalizeJson(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(canonicalizeJson).join(",") + "]";
+  }
+  const sortedObj = obj;
+  const keys = Object.keys(sortedObj).sort();
+  const pairs = keys.map(
+    (key) => `"${key}":${canonicalizeJson(sortedObj[key])}`
+  );
+  return "{" + pairs.join(",") + "}";
+}

package/dist/cjs/w/query/bult-in.d.ts

@@ -0,0 +1,73 @@
+import { OperatorType, WitnessType, ContextType } from "../common.js";
+import type { PermissionFilter, PermissionInfoType } from "../call/permission.js";
+import type { GuardInstructFilterOptions, GuardItem } from "../call/guard-ins.js";
+import type { ENTRYPOINT } from "../../client/network.js";
+interface ConstantItem {
+    name: string;
+    value: string | number;
+    description: string;
+}
+/**
+ * 预定义常量列表
+ */
+export declare const INFO_CONSTANT: {
+    type: string;
+    constants: ConstantItem[];
+    value_types: ConstantItem[];
+    object_types: ConstantItem[];
+    guard_instructions: {
+        name: string | OperatorType;
+        value: string | OperatorType;
+        description: string;
+    }[];
+    guard_contexts: {
+        name: string | ContextType;
+        value: string | ContextType;
+        description: string;
+    }[];
+    guard_witnesses: {
+        name: string | WitnessType;
+        value: string | WitnessType;
+        description: string;
+    }[];
+};
+export type ProtocolInfoQuery = {
+    info: "constants";
+} | {
+    info: "built-in permissions";
+    filter?: PermissionFilter;
+} | {
+    info: "guard instructions";
+    filter?: GuardInstructFilterOptions;
+} | {
+    info: "current network";
+} | {
+    info: "value types";
+};
+/**
+ * 查询结果类型
+ */
+export type ProtocolInfoResult = {
+    info: "constants";
+    result: ConstantItem[];
+} | {
+    info: "built-in permissions";
+    result: PermissionInfoType[];
+} | {
+    info: "guard instructions";
+    result: GuardItem[];
+} | {
+    info: "current network";
+    result: ENTRYPOINT;
+} | {
+    info: "value types";
+    result: ConstantItem[];
+};
+export declare function queryProtocolInfo(query: ProtocolInfoQuery): Promise<ProtocolInfoResult>;
+/**
+ * 查询权限信息
+ * @param filter 过滤条件
+ * @returns 权限信息数组
+ */
+export declare function queryPermissions(filter?: PermissionFilter): PermissionInfoType[];
+export {};

package/dist/cjs/w/query/bult-in.js

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bult_in_exports = {};
+__export(bult_in_exports, {
+  INFO_CONSTANT: () => INFO_CONSTANT,
+  queryPermissions: () => queryPermissions,
+  queryProtocolInfo: () => queryProtocolInfo
+});
+module.exports = __toCommonJS(bult_in_exports);
+var import_common = require("../common.js");
+var import_permission = require("../call/permission.js");
+var import_guard_ins = require("../call/guard-ins.js");
+var import_config = require("../local/config.js");
+const CONSTANTS = [
+  {
+    name: "Protocol Package ID",
+    value: import_common.PackageAddress,
+    description: "Protocol package ID"
+  },
+  {
+    name: "Gas Token Type",
+    value: import_common.GasTokenType,
+    description: "Gas token type"
+  },
+  {
+    name: "Gas Coin Type",
+    value: import_common.GasCoinType,
+    description: "Gas coin type"
+  },
+  {
+    name: "Entity Linker ID",
+    value: import_common.RegistrarAddress,
+    description: "Entity Linker ID"
+  },
+  {
+    name: "Entity Registrar ID",
+    value: import_common.EntityAddress,
+    description: "Entity registrar ID"
+  }
+];
+const VALUE_TYPES = Object.entries(import_common.ValueType).filter(([key, value]) => isNaN(Number(key)) && key !== "Value").map(([key, value]) => ({
+  name: key,
+  value: key,
+  // 输出字符串名称而不是数字
+  description: `Value type ${key} = ${value}`
+}));
+const OBJECT_TYPES = Object.values(import_common.ObjectType).map((type) => ({
+  name: type,
+  value: type,
+  description: `Object type ${type}`
+}));
+const INFO_CONSTANT = {
+  type: "constants",
+  constants: CONSTANTS,
+  value_types: VALUE_TYPES,
+  object_types: OBJECT_TYPES,
+  guard_instructions: Object.values(import_common.OperatorType).map((type) => ({
+    name: type,
+    value: type,
+    description: `Guard instruction ${type}`
+  })),
+  guard_contexts: Object.values(import_common.ContextType).map((type) => ({
+    name: type,
+    value: type,
+    description: `Guard context ${type}`
+  })),
+  guard_witnesses: Object.values(import_common.WitnessType).map((type) => ({
+    name: type,
+    value: type,
+    description: `Guard witness ${type}`
+  }))
+};
+async function queryProtocolInfo(query) {
+  switch (query.info) {
+    case "constants":
+      return { info: "constants", result: INFO_CONSTANT.constants };
+    case "built-in permissions":
+      return {
+        info: "built-in permissions",
+        result: queryPermissions(query.filter || {})
+      };
+    case "guard instructions":
+      return {
+        info: "guard instructions",
+        result: (0, import_guard_ins.filterGuardInstruct)(query.filter || {})
+      };
+    case "current network":
+      return {
+        info: "current network",
+        result: await import_config.Config.Instance().network_get()
+      };
+    case "value types":
+      return {
+        info: "value types",
+        result: INFO_CONSTANT.value_types
+      };
+    default:
+      throw new Error(
+        `Unsupported info type: "${query.info}". Valid are: "constants", "built-in permissions", "guard instructions", "current network", "value types"`
+      );
+  }
+}
+function queryPermissions(filter) {
+  return (0, import_permission.query_permissions)(filter);
+}

package/dist/cjs/w/query/event.d.ts

@@ -0,0 +1,82 @@
+import type { ENTRYPOINT } from "../../client/network.js";
+import type { BalanceType } from "../common.js";
+import type { ArbStatus } from "./object.js";
+/**
+ * Provide AI with Basic WoWok event queries:
+ * for real-time detail tracking.
+ */
+export interface EventBase {
+    id: {
+        eventSeq: string;
+        txDigest: string;
+    };
+    sender: string;
+    type: string | "ArbEvent" | "NewOrderEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent";
+    type_raw: string;
+    time: string;
+}
+export interface ArbEvent extends EventBase {
+    arb: string;
+    arbitration: string;
+    order: string;
+    status: ArbStatus;
+}
+export interface NewOrderEvent extends EventBase {
+    order: string;
+    service: string;
+    progress?: string | null;
+    discount?: string | null;
+    allocation?: string | null;
+    amount: BalanceType;
+}
+export interface ProgressEvent extends EventBase {
+    progress: string;
+    machine: string;
+    task?: string | null;
+    node: string;
+    forward?: string | null;
+    hold?: boolean | null;
+}
+export interface DemandPresentEvent extends EventBase {
+    demand: string;
+    service: string | null;
+    recommend: string;
+}
+export interface DemandFeedbackEvent extends EventBase {
+    demand: string;
+    service: string | null;
+    feedback: string;
+    acceptance_score?: number | null;
+}
+export interface NewEntityEvent extends EventBase {
+    address: string;
+    resource: string;
+    referrer: string | null;
+}
+export interface EventAnswer {
+    data: EventBase[];
+    hasNextPage: boolean;
+    nextCursor?: {
+        eventSeq: string;
+        txDigest: string;
+    } | null;
+    cache_expire?: number | "INFINITE";
+}
+export interface EventCursor {
+    eventSeq: string;
+    txDigest: string;
+}
+export type EventType = "ArbEvent" | "NewOrderEvent" | "ProgressEvent" | "DemandPresentEvent" | "DemandFeedbackEvent" | "NewEntityEvent";
+export interface EventQuery {
+    type: EventType;
+    /** optional paging cursor */
+    cursor?: EventCursor | null | undefined;
+    /** maximum number of items per page, default to [QUERY_MAX_RESULT_LIMIT] if not specified. */
+    limit?: number | null | undefined;
+    /** query result ordering, default to false (ascending order), oldest record first. */
+    order?: "ascending" | "descending" | null | undefined;
+    no_cache?: boolean;
+    network?: ENTRYPOINT;
+}
+export declare const query_events_json: (json: string) => Promise<string>;
+export declare const query_events: (query: EventQuery) => Promise<EventAnswer | undefined>;

package/dist/cjs/w/query/event.js

@@ -0,0 +1,157 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_exports = {};
+__export(event_exports, {
+  query_events: () => query_events,
+  query_events_json: () => query_events_json
+});
+module.exports = __toCommonJS(event_exports);
+var import_client = require("../../client/index.js");
+var import_common = require("../common.js");
+var import_local = require("../local/index.js");
+var import_cache = require("../local/cache.js");
+const query_events_json = async (json) => {
+  try {
+    const q = JSON.parse(json);
+    return JSON.stringify({ data: await query_events(q) });
+  } catch (e) {
+    return JSON.stringify({ error: e?.toString() });
+  }
+};
+const query_events = async (query) => {
+  const network = await import_local.Config.Instance().network_get(query.network);
+  const cursorStr = query.cursor ? `${query.cursor.eventSeq}:${query.cursor.txDigest}` : "";
+  const limitStr = query.limit?.toString() ?? "";
+  const orderStr = query.order ?? "";
+  const cachedResult = await import_cache.Cache.read(
+    [import_cache.CachePrefix.event, query.type, cursorStr, limitStr, orderStr, network],
+    async () => {
+      const result = await events(query.type, query);
+      return { expire: import_cache.Cache.DefaultExpireTime(), data: result };
+    },
+    query.no_cache
+  );
+  if (cachedResult) {
+    const d = cachedResult.data;
+    d.cache_expire = cachedResult.expire;
+    return d;
+  }
+  return void 0;
+};
+const events = async (type, query) => {
+  const network = await import_local.Config.Instance().network_get(query.network);
+  const client = new import_client.SuiClient({ url: (0, import_client.getFullnodeUrl)(network) });
+  const res = await client.queryEvents({
+    query: { MoveEventType: type },
+    cursor: query.cursor,
+    limit: query.limit,
+    order: query.order
+  });
+  const data = res?.data?.map((v) => {
+    if (v?.packageId === import_common.PackageAddress) {
+      if (v?.type?.includes("::order::NewOrderEvent")) {
+        return {
+          id: v?.id,
+          time: v?.timestampMs,
+          type_raw: v?.type,
+          sender: v?.sender,
+          type: "NewOrderEvent",
+          order: v?.parsedJson?.object,
+          service: v?.parsedJson?.service,
+          progress: v?.parsedJson?.progress?.some ?? null,
+          amount: v?.parsedJson?.amount,
+          discount: v?.parsedJson?.discount?.some ?? null,
+          allocation: v?.parsedJson?.allocation?.some ?? null
+        };
+      } else if (v?.type?.includes("::demand::PresentEvent")) {
+        return {
+          id: v?.id,
+          time: v?.timestampMs,
+          type_raw: v?.type,
+          sender: v?.sender,
+          type: "DemandPresentEvent",
+          demand: v?.parsedJson?.object,
+          service: v?.parsedJson?.service?.some ?? null,
+          recommend: v?.parsedJson?.tips
+        };
+      } else if (v?.type?.includes("::demand::DemandEvent")) {
+        return {
+          id: v?.id,
+          time: v?.timestampMs,
+          type_raw: v?.type,
+          sender: v?.sender,
+          type: "DemandFeedbackEvent",
+          demand: v?.parsedJson?.object,
+          service: v?.parsedJson?.service?.some ?? null,
+          feedback: v?.parsedJson?.feedback,
+          acceptance_score: v?.parsedJson?.acceptance_score?.some ?? null
+        };
+      } else if (v?.type?.includes("::progress::ProgressEvent")) {
+        return {
+          id: v?.id,
+          time: v?.timestampMs,
+          type_raw: v?.type,
+          sender: v?.sender,
+          type: "ProgressEvent",
+          progress: v?.parsedJson?.object,
+          machine: v?.parsedJson?.machine,
+          task: v?.parsedJson?.task,
+          node: v?.parsedJson?.node,
+          forward: v?.parsedJson?.forward,
+          hold: v?.parsedJson?.hold
+        };
+      } else if (v?.type?.includes("::arb::ArbEvent")) {
+        return {
+          id: v?.id,
+          time: v?.timestampMs,
+          type_raw: v?.type,
+          sender: v?.sender,
+          type: "ArbEvent",
+          arb: v?.parsedJson?.object,
+          arbitration: v?.parsedJson?.arbitration,
+          order: v?.parsedJson?.order,
+          status: v?.parsedJson?.status
+        };
+      } else if (v?.type?.includes("::entity::NewEntityEvent")) {
+        return {
+          id: v?.id,
+          time: v?.timestampMs,
+          type_raw: v?.type,
+          sender: v?.sender,
+          type: "NewEntityEvent",
+          resource: v?.parsedJson?.resource,
+          address: v?.sender,
+          referrer: v?.parsedJson?.referrer?.some ?? null
+        };
+      }
+    }
+    return {
+      id: v?.id,
+      time: v?.timestampMs,
+      type_raw: v?.type,
+      sender: v?.sender,
+      type: ""
+    };
+  });
+  return {
+    data,
+    hasNextPage: res?.hasNextPage,
+    nextCursor: res?.nextCursor
+  };
+};

package/dist/cjs/w/query/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./object.js";
+export * from "./util.js";
+export * from "./event.js";
+export * from "./received.js";
+export * from "./bult-in.js";

package/dist/cjs/w/query/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_exports = {};
+module.exports = __toCommonJS(query_exports);
+__reExport(query_exports, require("./object.js"), module.exports);
+__reExport(query_exports, require("./util.js"), module.exports);
+__reExport(query_exports, require("./event.js"), module.exports);
+__reExport(query_exports, require("./received.js"), module.exports);
+__reExport(query_exports, require("./bult-in.js"), module.exports);