@fedify/amqp 0.2.0 → 0.3.0-dev.17

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@fedify/amqp",
-  "version": "0.2.0",
+  "version": "0.3.0-dev.17+484159bd",
   "description": "AMQP/RabbitMQ driver for Fedify",
   "keywords": [
     "fedify",
     "amqp",
     "rabbitmq"
   ],
+  "license": "MIT",
   "author": {
     "name": "Hong Minhee",
     "email": "hong@minhee.org",
@@ -17,45 +18,42 @@
     "type": "git",
     "url": "git+https://github.com/fedify-dev/amqp.git"
   },
-  "license": "MIT",
   "bugs": {
     "url": "https://github.com/fedify-dev/amqp/issues"
   },
-  "main": "./script/mod.js",
-  "module": "./esm/mod.js",
-  "types": "./types/mod.d.ts",
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "main": "./dist/mod.js",
+  "module": "./dist/mod.js",
+  "types": "./dist/mod.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/mod.d.ts",
-        "default": "./esm/mod.js"
-      },
-      "require": {
-        "types": "./types/mod.d.ts",
-        "default": "./script/mod.js"
-      }
+      "import": "./dist/mod.js",
+      "types": "./dist/mod.d.ts"
     },
-    "./mq": {
-      "import": {
-        "types": "./types/src/mq.d.ts",
-        "default": "./esm/src/mq.js"
-      },
-      "require": {
-        "types": "./types/src/mq.d.ts",
-        "default": "./script/src/mq.js"
-      }
-    }
+    "./package.json": "./package.json"
   },
-  "funding": [
-    "https://github.com/sponsors/dahlia"
-  ],
-  "dependencies": {
-    "@fedify/fedify": "^1.5.0",
-    "amqplib": "^0.10.4"
+  "peerDependencies": {
+    "@fedify/fedify": "^1.7.0-dev.887",
+    "amqplib": "^0.10.8"
   },
   "devDependencies": {
-    "@types/node": "^20.9.0",
-    "@types/amqplib": "0.10.6"
+    "@hongminhee/suite": "^0.6.3",
+    "@js-temporal/polyfill": "^0.5.1",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "@std/async": "npm:@jsr/std__async@^1.0.13",
+    "@types/amqplib": "^0.10.7",
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
   },
-  "_generatedBy": "dnt@dev"
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test --timeout 15000",
+    "test:deno": "deno task test",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test --timeout 15000 && deno task test"
+  }
 }

package/src/mod.ts

@@ -0,0 +1 @@
+export * from "./mq.ts";

package/src/mq.test.ts

@@ -0,0 +1,186 @@
+import { suite } from "@hongminhee/suite";
+import * as temporal from "@js-temporal/polyfill";
+import { assert, assertEquals, assertFalse, assertGreater } from "@std/assert";
+import { delay } from "@std/async/delay";
+// @deno-types="npm:@types/amqplib"
+import { type ChannelModel, connect } from "amqplib";
+import process from "node:process";
+import { AmqpMessageQueue } from "./mq.ts";
+
+let Temporal: typeof temporal.Temporal;
+if ("Temporal" in globalThis) {
+  Temporal = globalThis.Temporal;
+} else {
+  Temporal = temporal.Temporal;
+}
+
+const test = suite(import.meta);
+
+function getConnection(): Promise<ChannelModel> {
+  const url = process.env.AMQP_URL;
+  return connect(url ?? "amqp://localhost");
+}
+
+test("AmqpMessageQueue", {
+  sanitizeOps: false,
+  sanitizeExit: false,
+  sanitizeResources: false,
+}, async () => {
+  const conn = await getConnection();
+  const conn2 = await getConnection();
+  const randomSuffix = Math.random().toString(36).substring(2);
+  const queue = `fedify_queue_${randomSuffix}`;
+  const delayedQueuePrefix = `fedify_delayed_${randomSuffix}_`;
+  const mq = new AmqpMessageQueue(conn, { queue, delayedQueuePrefix });
+  const mq2 = new AmqpMessageQueue(conn2, { queue, delayedQueuePrefix });
+
+  const messages1: string[] = [];
+  const messages2: string[] = [];
+  const allMessages: string[] = [];
+  const controller = new AbortController();
+  const listening = mq.listen((message: string) => {
+    messages1.push(message);
+    allMessages.push(message);
+  }, { signal: controller.signal });
+  const listening2 = mq2.listen((message: string) => {
+    messages2.push(message);
+    allMessages.push(message);
+  }, { signal: controller.signal });
+
+  await mq.enqueue("Hello, world!");
+
+  await waitFor(() => allMessages.length > 0, 15_000);
+
+  assertEquals(allMessages.includes("Hello, world!"), true);
+
+  // enqueue() with delay
+  const started = Date.now();
+  await mq.enqueue(
+    "Delayed message",
+    { delay: Temporal.Duration.from({ seconds: 3 }) },
+  );
+
+  await waitFor(() => allMessages.includes("Delayed message"), 15_000);
+
+  // listen() with delay
+  assertEquals(allMessages.includes("Delayed message"), true);
+  assertGreater(Date.now() - started, 3_000);
+
+  await mq.enqueueMany(["Message 1", "Message 2", "Message 3"]);
+
+  await waitFor(() =>
+    allMessages.includes("Message 1") &&
+    allMessages.includes("Message 2") &&
+    allMessages.includes("Message 3"), 15_000);
+
+  // listen() after enqueueMany()
+  assertEquals(allMessages.includes("Message 1"), true);
+  assertEquals(allMessages.includes("Message 2"), true);
+  assertEquals(allMessages.includes("Message 3"), true);
+
+  // enqueueMany() with delay
+  const manyStarted = Date.now();
+  await mq.enqueueMany(
+    ["Delayed batch 1", "Delayed batch 2"],
+    { delay: Temporal.Duration.from({ seconds: 3 }) },
+  );
+
+  await waitFor(() =>
+    allMessages.includes("Delayed batch 1") &&
+    allMessages.includes("Delayed batch 2"), 15_000);
+
+  // listen() after enqueueMany() with delay
+  assertEquals(allMessages.includes("Delayed batch 1"), true);
+  assertEquals(allMessages.includes("Delayed batch 2"), true);
+  assertGreater(Date.now() - manyStarted, 3_000);
+
+  controller.abort();
+  await listening;
+  await listening2;
+
+  await conn.close();
+  await conn2.close();
+});
+
+test(
+  "AmqpMessageQueue [nativeRetrial: false]",
+  { sanitizeOps: false, sanitizeExit: false, sanitizeResources: false },
+  async () => {
+    const conn = await getConnection();
+    const randomSuffix = Math.random().toString(36).substring(2);
+    const queue = `fedify_queue_${randomSuffix}`;
+    const delayedQueuePrefix = `fedify_delayed_${randomSuffix}_`;
+    const mq = new AmqpMessageQueue(conn, { queue, delayedQueuePrefix });
+    assertFalse(mq.nativeRetrial);
+
+    const controller = new AbortController();
+    let i = 0;
+    const listening = mq.listen((message: string) => {
+      if (message !== "Hello, world!") return;
+      if (i++ < 1) {
+        throw new Error("Test error to check native retrial");
+      }
+    }, { signal: controller.signal });
+
+    await mq.enqueue("Hello, world!");
+
+    await waitFor(() => i >= 1, 15_000);
+    assertEquals(i, 1);
+    await delay(5_000);
+
+    controller.abort();
+    await listening;
+    await conn.close();
+
+    assertEquals(i, 1);
+  },
+);
+
+test(
+  "AmqpMessageQueue [nativeRetrial: true]",
+  { sanitizeOps: false, sanitizeExit: false, sanitizeResources: false },
+  async () => {
+    const conn = await getConnection();
+    const randomSuffix = Math.random().toString(36).substring(2);
+    const queue = `fedify_queue_${randomSuffix}`;
+    const delayedQueuePrefix = `fedify_delayed_${randomSuffix}_`;
+    const mq = new AmqpMessageQueue(conn, {
+      queue,
+      delayedQueuePrefix,
+      nativeRetrial: true,
+    });
+    assert(mq.nativeRetrial);
+
+    const controller = new AbortController();
+    let i = 0;
+    const listening = mq.listen((message: string) => {
+      if (message !== "Hello, world!") return;
+      if (i++ < 1) {
+        throw new Error("Test error to check native retrial");
+      }
+    }, { signal: controller.signal });
+
+    await mq.enqueue("Hello, world!");
+
+    await waitFor(() => i > 1, 15_000);
+
+    controller.abort();
+    await listening;
+    await conn.close();
+
+    assertGreater(i, 1);
+  },
+);
+
+async function waitFor(
+  predicate: () => boolean,
+  timeoutMs: number,
+): Promise<void> {
+  const started = Date.now();
+  while (!predicate()) {
+    await delay(500);
+    if (Date.now() - started > timeoutMs) {
+      throw new Error("Timeout");
+    }
+  }
+}

package/src/mq.ts

@@ -0,0 +1,214 @@
+import type {
+  MessageQueue,
+  MessageQueueEnqueueOptions,
+  MessageQueueListenOptions,
+} from "@fedify/fedify";
+// @deno-types="npm:@types/amqplib@^0.10.7"
+import type { Channel, ChannelModel } from "amqplib";
+import { Buffer } from "node:buffer";
+
+/**
+ * Options for {@link AmqpMessageQueue}.
+ */
+export interface AmqpMessageQueueOptions {
+  /**
+   * The name of the queue to use.  Defaults to `"fedify_queue"`.
+   * @default `"fedify_queue"`
+   */
+  queue?: string;
+
+  /**
+   * The prefix to use for the delayed queue.  Defaults to `"fedify_delayed_"`.
+   * Defaults to `"fedify_delayed_"`.
+   * @default `"fedify_delayed_"`
+   */
+  delayedQueuePrefix?: string;
+
+  /**
+   * Whether the queue will survive a broker restart.  Defaults to `true`.
+   * @default `true`
+   */
+  durable?: boolean;
+
+  /**
+   * Whether to use native retrial mechanism. If set to `true`, the queue will
+   * not acknowledge messages that are not processed successfully, allowing
+   * them to be retried later. If set to `false`, messages will be acknowledged
+   * whether they are processed successfully or not.
+   *
+   * Both approaches have their own advantages and disadvantages.  With native
+   * retrials, much less chance of losing messages, but timing of retrials is
+   * less predictable.  With non-native retrials, retrials are handled by Fedify
+   * itself, which allows for more control over the timing and behavior of
+   * retrials, but may result in lost messages if the process crashes before
+   * acknowledging the message.
+   * @default `false`
+   */
+  nativeRetrial?: boolean;
+}
+
+/**
+ * A message queue that uses AMQP.
+ *
+ * @example
+ * ``` typescript
+ * import { createFederation } from "@fedify/fedify";
+ * import { AmqpMessageQueue } from "@fedify/amqp";
+ * import { connect } from "amqplib";
+ *
+ * const federation = createFederation({
+ *   queue: new AmqpMessageQueue(await connect("amqp://localhost")),
+ *   // ... other configurations
+ * });
+ * ```
+ */
+export class AmqpMessageQueue implements MessageQueue {
+  #connection: ChannelModel;
+  #queue: string;
+  #delayedQueuePrefix: string;
+  #durable: boolean;
+  #senderChannel?: Channel;
+
+  readonly nativeRetrial: boolean;
+
+  /**
+   * Creates a new `AmqpMessageQueue`.
+   * @param connection A connection to the AMQP server.
+   * @param options Options for the message queue.
+   */
+  constructor(
+    connection: ChannelModel,
+    options: AmqpMessageQueueOptions = {},
+  ) {
+    this.#connection = connection;
+    this.#queue = options.queue ?? "fedify_queue";
+    this.#delayedQueuePrefix = options.delayedQueuePrefix ?? "fedify_delayed_";
+    this.#durable = options.durable ?? true;
+    this.nativeRetrial = options.nativeRetrial ?? false;
+  }
+
+  async #prepareQueue(channel: Channel): Promise<void> {
+    await channel.assertQueue(this.#queue, {
+      durable: this.#durable,
+    });
+  }
+
+  async #getSenderChannel(): Promise<Channel> {
+    if (this.#senderChannel != null) return this.#senderChannel;
+    const channel = await this.#connection.createChannel();
+    this.#senderChannel = channel;
+    this.#prepareQueue(channel);
+    return channel;
+  }
+
+  async enqueue(
+    // deno-lint-ignore no-explicit-any
+    message: any,
+    options?: MessageQueueEnqueueOptions,
+  ): Promise<void> {
+    const channel = await this.#getSenderChannel();
+    const delay = options?.delay?.total("millisecond");
+    let queue: string;
+    if (delay == null || delay <= 0) {
+      queue = this.#queue;
+    } else {
+      const delayStr = delay.toLocaleString("en", { useGrouping: false });
+      queue = this.#delayedQueuePrefix + delayStr;
+      await channel.assertQueue(queue, {
+        autoDelete: true,
+        durable: this.#durable,
+        deadLetterExchange: "",
+        deadLetterRoutingKey: this.#queue,
+        messageTtl: delay,
+      });
+    }
+    channel.sendToQueue(
+      queue,
+      Buffer.from(JSON.stringify(message), "utf-8"),
+      {
+        persistent: this.#durable,
+        contentType: "application/json",
+      },
+    );
+  }
+
+  async enqueueMany(
+    // deno-lint-ignore no-explicit-any
+    messages: any[],
+    options?: MessageQueueEnqueueOptions,
+  ): Promise<void> {
+    const channel = await this.#getSenderChannel();
+    const delay = options?.delay?.total("millisecond");
+    let queue: string;
+    if (delay == null || delay <= 0) {
+      queue = this.#queue;
+    } else {
+      const delayStr = delay.toLocaleString("en", { useGrouping: false });
+      queue = this.#delayedQueuePrefix + delayStr;
+      await channel.assertQueue(queue, {
+        autoDelete: true,
+        durable: this.#durable,
+        deadLetterExchange: "",
+        deadLetterRoutingKey: this.#queue,
+        messageTtl: delay,
+      });
+    }
+
+    for (const message of messages) {
+      channel.sendToQueue(
+        queue,
+        Buffer.from(JSON.stringify(message), "utf-8"),
+        {
+          persistent: this.#durable,
+          contentType: "application/json",
+        },
+      );
+    }
+  }
+
+  async listen(
+    // deno-lint-ignore no-explicit-any
+    handler: (message: any) => void | Promise<void>,
+    options: MessageQueueListenOptions = {},
+  ): Promise<void> {
+    const channel = await this.#connection.createChannel();
+    await this.#prepareQueue(channel);
+    await channel.prefetch(1);
+    const reply = await channel.consume(this.#queue, (msg) => {
+      if (msg == null) return;
+      const message = JSON.parse(msg.content.toString("utf-8"));
+      try {
+        const result = handler(message);
+        if (result instanceof Promise) {
+          if (this.nativeRetrial) {
+            result
+              .then(() => channel.ack(msg))
+              .catch(() => channel.nack(msg, undefined, true));
+          } else {
+            result.finally(() => channel.ack(msg));
+          }
+        } else if (this.nativeRetrial) {
+          channel.ack(msg);
+        }
+      } catch {
+        if (this.nativeRetrial) {
+          channel.nack(msg, undefined, true);
+        }
+      } finally {
+        if (!this.nativeRetrial) {
+          channel.ack(msg);
+        }
+      }
+    }, {
+      noAck: false,
+    });
+    return await new Promise((resolve) => {
+      if (options.signal?.aborted) resolve();
+      options.signal?.addEventListener("abort", () => {
+        channel.cancel(reply.consumerTag).then(() => {
+          channel.close().then(() => resolve());
+        });
+      });
+    });
+  }
+}

package/tsdown.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: "mod.ts",
+  dts: true,
+  platform: "node",
+});

package/esm/mod.js

@@ -1 +0,0 @@
-export * from "./src/mod.js";

package/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/esm/src/mod.js

@@ -1 +0,0 @@
-export * from "./mq.js";

package/esm/src/mq.js

@@ -1,139 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _AmqpMessageQueue_instances, _AmqpMessageQueue_connection, _AmqpMessageQueue_queue, _AmqpMessageQueue_delayedQueuePrefix, _AmqpMessageQueue_durable, _AmqpMessageQueue_senderChannel, _AmqpMessageQueue_prepareQueue, _AmqpMessageQueue_getSenderChannel;
-import { Buffer } from "node:buffer";
-/**
- * A message queue that uses AMQP.
- *
- * @example
- * ``` typescript
- * import { createFederation } from "@fedify/fedify";
- * import { AmqpMessageQueue } from "@fedify/amqp";
- * import { connect } from "amqplib";
- *
- * const federation = createFederation({
- *   queue: new AmqpMessageQueue(await connect("amqp://localhost")),
- *   // ... other configurations
- * });
- * ```
- */
-export class AmqpMessageQueue {
-    /**
-     * Creates a new `AmqpMessageQueue`.
-     * @param connection A connection to the AMQP server.
-     * @param options Options for the message queue.
-     */
-    constructor(connection, options = {}) {
-        _AmqpMessageQueue_instances.add(this);
-        _AmqpMessageQueue_connection.set(this, void 0);
-        _AmqpMessageQueue_queue.set(this, void 0);
-        _AmqpMessageQueue_delayedQueuePrefix.set(this, void 0);
-        _AmqpMessageQueue_durable.set(this, void 0);
-        _AmqpMessageQueue_senderChannel.set(this, void 0);
-        __classPrivateFieldSet(this, _AmqpMessageQueue_connection, connection, "f");
-        __classPrivateFieldSet(this, _AmqpMessageQueue_queue, options.queue ?? "fedify_queue", "f");
-        __classPrivateFieldSet(this, _AmqpMessageQueue_delayedQueuePrefix, options.delayedQueuePrefix ?? "fedify_delayed_", "f");
-        __classPrivateFieldSet(this, _AmqpMessageQueue_durable, options.durable ?? true, "f");
-    }
-    async enqueue(
-    // deno-lint-ignore no-explicit-any
-    message, options) {
-        const channel = await __classPrivateFieldGet(this, _AmqpMessageQueue_instances, "m", _AmqpMessageQueue_getSenderChannel).call(this);
-        const delay = options?.delay?.total("millisecond");
-        let queue;
-        if (delay == null || delay <= 0) {
-            queue = __classPrivateFieldGet(this, _AmqpMessageQueue_queue, "f");
-        }
-        else {
-            const delayStr = delay.toLocaleString("en", { useGrouping: false });
-            queue = __classPrivateFieldGet(this, _AmqpMessageQueue_delayedQueuePrefix, "f") + delayStr;
-            await channel.assertQueue(queue, {
-                autoDelete: true,
-                durable: __classPrivateFieldGet(this, _AmqpMessageQueue_durable, "f"),
-                deadLetterExchange: "",
-                deadLetterRoutingKey: __classPrivateFieldGet(this, _AmqpMessageQueue_queue, "f"),
-                messageTtl: delay,
-            });
-        }
-        channel.sendToQueue(queue, Buffer.from(JSON.stringify(message), "utf-8"), {
-            persistent: __classPrivateFieldGet(this, _AmqpMessageQueue_durable, "f"),
-            contentType: "application/json",
-        });
-    }
-    async enqueueMany(
-    // deno-lint-ignore no-explicit-any
-    messages, options) {
-        const channel = await __classPrivateFieldGet(this, _AmqpMessageQueue_instances, "m", _AmqpMessageQueue_getSenderChannel).call(this);
-        const delay = options?.delay?.total("millisecond");
-        let queue;
-        if (delay == null || delay <= 0) {
-            queue = __classPrivateFieldGet(this, _AmqpMessageQueue_queue, "f");
-        }
-        else {
-            const delayStr = delay.toLocaleString("en", { useGrouping: false });
-            queue = __classPrivateFieldGet(this, _AmqpMessageQueue_delayedQueuePrefix, "f") + delayStr;
-            await channel.assertQueue(queue, {
-                autoDelete: true,
-                durable: __classPrivateFieldGet(this, _AmqpMessageQueue_durable, "f"),
-                deadLetterExchange: "",
-                deadLetterRoutingKey: __classPrivateFieldGet(this, _AmqpMessageQueue_queue, "f"),
-                messageTtl: delay,
-            });
-        }
-        for (const message of messages) {
-            channel.sendToQueue(queue, Buffer.from(JSON.stringify(message), "utf-8"), {
-                persistent: __classPrivateFieldGet(this, _AmqpMessageQueue_durable, "f"),
-                contentType: "application/json",
-            });
-        }
-    }
-    async listen(
-    // deno-lint-ignore no-explicit-any
-    handler, options = {}) {
-        const channel = await __classPrivateFieldGet(this, _AmqpMessageQueue_connection, "f").createChannel();
-        await __classPrivateFieldGet(this, _AmqpMessageQueue_instances, "m", _AmqpMessageQueue_prepareQueue).call(this, channel);
-        await channel.prefetch(1);
-        const reply = await channel.consume(__classPrivateFieldGet(this, _AmqpMessageQueue_queue, "f"), (msg) => {
-            if (msg == null)
-                return;
-            const message = JSON.parse(msg.content.toString("utf-8"));
-            const result = handler(message);
-            if (result instanceof Promise) {
-                result.finally(() => channel.ack(msg));
-            }
-            else {
-                channel.ack(msg);
-            }
-        }, {
-            noAck: false,
-        });
-        return await new Promise((resolve) => {
-            options.signal?.addEventListener("abort", () => {
-                channel.cancel(reply.consumerTag).then(() => {
-                    channel.close().then(() => resolve());
-                });
-            });
-        });
-    }
-}
-_AmqpMessageQueue_connection = new WeakMap(), _AmqpMessageQueue_queue = new WeakMap(), _AmqpMessageQueue_delayedQueuePrefix = new WeakMap(), _AmqpMessageQueue_durable = new WeakMap(), _AmqpMessageQueue_senderChannel = new WeakMap(), _AmqpMessageQueue_instances = new WeakSet(), _AmqpMessageQueue_prepareQueue = async function _AmqpMessageQueue_prepareQueue(channel) {
-    await channel.assertQueue(__classPrivateFieldGet(this, _AmqpMessageQueue_queue, "f"), {
-        durable: __classPrivateFieldGet(this, _AmqpMessageQueue_durable, "f"),
-    });
-}, _AmqpMessageQueue_getSenderChannel = async function _AmqpMessageQueue_getSenderChannel() {
-    if (__classPrivateFieldGet(this, _AmqpMessageQueue_senderChannel, "f") != null)
-        return __classPrivateFieldGet(this, _AmqpMessageQueue_senderChannel, "f");
-    const channel = await __classPrivateFieldGet(this, _AmqpMessageQueue_connection, "f").createChannel();
-    __classPrivateFieldSet(this, _AmqpMessageQueue_senderChannel, channel, "f");
-    __classPrivateFieldGet(this, _AmqpMessageQueue_instances, "m", _AmqpMessageQueue_prepareQueue).call(this, channel);
-    return channel;
-};

package/script/mod.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/mod.js"), exports);

package/script/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}