duo-map 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kasukabe tsumugi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,218 @@
-# Temporary Holding Version
+# duo-map
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/duo-map.svg)](https://www.npmjs.com/package/duo-map) [![npm downloads](http://img.shields.io/npm/dm/duo-map.svg)](https://npmcharts.com/compare/duo-map,token-types?start=1200&interval=30)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/59dd6795e61949fb97066ca52e6097ef)](https://www.codacy.com/app/Borewit/duo-map?utm_source=github.com&utm_medium=referral&utm_content=Borewit/duo-map&utm_campaign=Badge_Grade)
+
+A `Map` that maps **two keys to a single value**. Think of it as a nested `Map<Map>` with a flat API — no manual `get`/`set` bookkeeping of the inner map.
+
+For more awesome packages, check out [my homepage💛](https://baendlorel.github.io/?repoType=npm)
+
+## Features
+
+- 🗝️ **Two keys, one lookup**: `get(key1, key2)` replaces the `map.get(a)?.get(b)` dance.
+- 🌲 **Nested semantics**: entries are grouped by `key1`, but the API is flat.
+- 🧹 **Self-cleaning**: deleting the last pair of a `key1` group removes the group itself.
+- 💤 **Lazy inserts**: `getOrInsertComputed` only computes when the pair is actually missing.
+- 🔒 **Type safe**: three independent generic parameters `DuoMap<K1, K2, V>`.
+- ⚡ **Lightweight**: no dependencies, zero runtime overhead over plain nested `Map`s.
+
+## Installation / Import
+
+```bash
+npm install duo-map
+# or
+pnpm add duo-map
+# or
+yarn add duo-map
+```
+
+```ts
+import { DuoMap } from 'duo-map';
+```
+
+## Usage
+
+```ts
+import { DuoMap } from 'duo-map';
+
+const map = new DuoMap<string, number, string>();
+
+// set(key1, key2, value) — returns `this`, so calls chain
+map.set('users', 1, 'alice');
+map.set('users', 2, 'bob').set('posts', 1, 'hello');
+
+// get(key1, key2)
+map.get('users', 1); // 'alice'
+map.get('users', 2); // 'bob'
+map.get('users', 3); // undefined — no such key2
+map.get('missing', 1); // undefined — no such key1
+```
+
+The same `key2` under a different `key1` is a **different entry**, so namespaces stay independent:
+
+```ts
+map.set('users', 1, 'alice');
+map.set('posts', 1, 'hello');
+
+map.get('users', 1); // 'alice'
+map.get('posts', 1); // 'hello'
+map.size; // 2 — not 1
+```
+
+### Memoizing with a lazy default
+
+`getOrInsertComputed` runs the factory only when the pair is missing, which makes it a natural fit for memoization:
+
+```ts
+type User = { id: number; name: string };
+const cache = new DuoMap<string, number, User>();
+
+function getUser(tenant: string, id: number): User {
+  return cache.getOrInsertComputed(tenant, id, () => fetchUserFromDb(tenant, id));
+}
+
+// Computed once, then served from the cache.
+getUser('acme', 1);
+getUser('acme', 1);
+```
+
+If the factory throws, nothing is written, so the next call retries instead of caching a failure:
+
+```ts
+let attempts = 0;
+const map = new DuoMap<string, string, number>();
+
+expect(() =>
+  map.getOrInsertComputed('a', 'x', () => {
+    attempts++;
+    throw new Error('db down');
+  }),
+).toThrow('db down');
+
+map.has('a', 'x'); // false — no half-written entry
+```
+
+Use `getOrInsert` when the default value is already on hand and cheap to build:
+
+```ts
+const counters = new DuoMap<string, string, number>();
+
+counters.getOrInsert('page', '/home', 0); // 0 — inserted
+counters.getOrInsert('page', '/home', 99); // 0 — already there, 99 ignored
+```
+
+> Note: the default passed to `getOrInsert` is a plain argument, so it is evaluated on **every** call even when it is not used. If building it is expensive, reach for `getOrInsertComputed`, which defers the factory until the pair is actually missing.
+
+### Inspecting and iterating
+
+```ts
+const map = new DuoMap<string, string, number>();
+map.set('a', 'x', 1)
+   .set('a', 'y', 2)
+   .set('b', 'x', 3);
+
+map.size;    // 3 — counts pairs, not key1 groups
+map.keys();    // [['a', 'x'], ['a', 'y'], ['b', 'x']]
+map.values();  // [1, 2, 3]
+map.entries(); // [['a', 'x', 1], ['a', 'y', 2], ['b', 'x', 3]]
+
+map.forEach((value, key1, key2) => {
+  console.log(key1, key2, value);
+});
+
+for (const [key1, key2, value] of map) {
+  console.log(key1, key2, value);
+}
+
+map.delete('a', 'x'); // true — 'a' still holds 'y', so the group survives
+map.delete('a', 'y'); // true — last pair of 'a' gone, the group is dropped too
+map.clear();
+```
+
+## API
+
+### `new DuoMap<K1, K2, V>()`
+
+Creates an empty map. All three type parameters default to `any`.
+
+```ts
+const loosely = new DuoMap();              // DuoMap<any, any, any>
+const typed = new DuoMap<string, number, User>();
+```
+
+### `.set(key1: K1, key2: K2, value: V): this`
+
+Stores `value` under the pair, overwriting any previous value. The `key1` group is created on demand. Returns `this` for chaining.
+
+### `.get(key1: K1, key2: K2): V | undefined`
+
+Returns the value stored under the pair, or `undefined` if the pair is absent. A stored `undefined` is indistinguishable from an absent pair here — use `has` when that matters.
+
+### `.getOrInsert(key1: K1, key2: K2, value: V): V`
+
+Returns the existing value if the pair is present, otherwise stores `value` and returns it. Presence is tested with `has`, so an explicitly stored `undefined` is preserved rather than replaced.
+
+### `.getOrInsertComputed(key1: K1, key2: K2, compute: () => V): V`
+
+Like `getOrInsert`, but `compute` is a factory invoked only when the pair is absent. If `compute` throws, the map is left untouched. Mirrors the [upsert proposal](https://github.com/tc39/proposal-upsert) (`Map.prototype.getOrInsertComputed`, Stage 4).
+
+### `.has(key1: K1, key2: K2): boolean`
+
+Returns `true` if the pair exists, including when its value is `undefined`. Does not create the group as a side effect.
+
+### `.delete(key1: K1, key2: K2): boolean`
+
+Removes the pair and reports whether it existed. When that was the group's last pair, the `key1` group is removed as well.
+
+### `.clear(): void`
+
+Removes every entry.
+
+### `.size: number`
+
+The total number of **pairs** across all `key1` groups, computed on each read by summing the group sizes. O(number of `key1` groups), unlike native `Map.size` which is O(1).
+
+### `.forEach(callback: (value: V, key1: K1, key2: K2) => void): void`
+
+Invokes `callback` for each pair. Note the argument order places the value first, and there is no index or collection argument.
+
+### `.keys(): [K1, K2][]`
+
+Returns an array of `[key1, key2]` pairs.
+
+### `.values(): V[]`
+
+Returns an array of all values.
+
+### `.entries(): [K1, K2, V][]`
+
+Returns an array of `[key1, key2, value]` triples.
+
+### `[Symbol.iterator](): Iterator<[K1, K2, V]>`
+
+Yields `[key1, key2, value]` triples, enabling `for...of` and spread.
+
+> `keys()`, `values()`, `entries()` and the iterator all return **snapshots** built from the current state, not live views. Adding entries while iterating will not visit them, and mutating a returned array does not affect the map.
+
+> Ordering follows native `Map`: entries come back grouped by `key1` in insertion order, and within a group by `key2` in insertion order.
+
+### Key equality
+
+Keys are compared with **SameValueZero**, exactly like native `Map` — `NaN` matches `NaN`, `+0` and `-0` are the same key, and object keys match by reference.
+
+## Differences from native `Map`
+
+| Feature               | `Map`                 | `DuoMap`                                     |
+| --------------------- | --------------------- | -------------------------------------------- |
+| Keys per entry        | 1                     | 2                                            |
+| Read / write          | `(key)`               | `(key1, key2)`                               |
+| Iteration yields      | `[key, value]`        | `[key1, key2, value]`                        |
+| `forEach` callback    | `(value, key, map)`   | `(value, key1, key2)`                        |
+| `keys()` / `values()` | iterators             | plain arrays                                 |
+| `getOrInsert`         | proposal only         | shipped, with a lazy `getOrInsertComputed`   |
+| Empty group cleanup   | —                     | `key1` group dropped with its last `delete`  |
+| `.size`               | O(1)                  | O(number of `key1` groups)                   |
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),Array.isArray,Array.from,Array.prototype.concat,Array.prototype.filter,Array.prototype.push,Array.prototype.slice,Array.prototype.splice,Function.prototype.toString,Number.isNaN,Number.isInteger,Number.isSafeInteger,Number.isFinite;const e=(e,t,n)=>(e.has(t)||e.set(t,n),e.get(t)),t=(e,t,n)=>(e.has(t)||e.set(t,n(t)),e.get(t)),n=()=>/* @__PURE__ */ new Map;var r=class{map=/* @__PURE__ */ new Map;get size(){let e=0;return this.map.forEach(t=>e+=t.size),e}set(e,r,i){return t(this.map,e,n).set(r,i),this}get(e,t){return this.map.get(e)?.get(t)}getOrInsert(r,i,a){let o=t(this.map,r,n);return e(o,i,a)}getOrInsertComputed(e,r,i){let a=t(this.map,e,n);return t(a,r,()=>i(e,r))}has(e,t){return this.map.get(e)?.has(t)??!1}delete(e,t){let n=this.map.get(e);if(!n)return!1;let r=n.delete(t);return n.size===0&&this.map.delete(e),r}clear(){this.map.clear()}forEach(e){this.map.forEach((t,n)=>t.forEach((t,r)=>e(t,n,r)))}keys(){let e=[];return this.map.forEach((t,n)=>t.forEach((t,r)=>e.push([n,r]))),e}values(){let e=[];return this.map.forEach(t=>t.forEach(t=>e.push(t))),e}entries(){let e=[];return this.map.forEach((t,n)=>t.forEach((t,r)=>e.push([n,r,t]))),e}[Symbol.iterator](){let e=this.entries(),t=0;return{next(){return t<e.length?{value:e[t++],done:!1}:{value:void 0,done:!0}}}}};exports.DuoMap=r;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["_getOrInsert","map","key","value","_getOrInsertComputed","compute","MapConstruct","DuoMap","count","m","key1","key2","result","callback","entries","index"],"sources":["../../_shared/native/std.ts","../src/index.ts"],"sourcesContent":["// Cached native methods for performance optimization\n\n// # Array\nexport const $isArray = Array.isArray;\nexport const $arrayFrom = Array.from;\nexport const $concat = Array.prototype.concat;\nexport const $filter = Array.prototype.filter;\nexport const $push = Array.prototype.push;\nexport const $slice = Array.prototype.slice;\nexport const $splice = Array.prototype.splice;\n\n// # Object\nexport const $fnToString = Function.prototype.toString;\nexport const $toString = Object.prototype.toString;\nexport const $ObjectPrototype = Object.prototype;\nexport const $is = Object.is;\nexport const $assign = Object.assign;\nexport const $hasOwn = Object.prototype.hasOwnProperty;\nexport const $keys = Object.keys as <T>(o: T) => Array<keyof T>;\nexport const $define = Object.defineProperty;\nexport const $defines = Object.defineProperties;\nexport const $entries = Object.entries as <T>(o: T) => Array<[keyof T, T[keyof T]]>;\nexport const $jsonStringify = JSON.stringify;\nexport const $getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;\nexport const $freeze = Object.freeze;\n\n// # Reflect\n\nexport const $set = Reflect.set;\nexport const $get = Reflect.get;\nexport const $has = Reflect.has;\nexport const $ownKeys = Reflect.ownKeys;\n// & Do not use `Object.defineProperty`\nexport const $reflectDefine = Reflect.defineProperty;\nexport const $delete = Reflect.deleteProperty;\nexport const $getPrototypeOf = Reflect.getPrototypeOf;\nexport const $setPrototypeOf = Reflect.setPrototypeOf;\n\n// # Math and related utilities\nexport const $max = Math.max;\nexport const $min = Math.min;\nexport const $floor = Math.floor;\nexport const $random = Math.random;\nexport const $randomInt = (min: number, max: number) => $floor($random() * (max - min + 1)) + min;\n\n// # Number\nexport const $isNaN = Number.isNaN;\nexport const $isInt = Number.isInteger;\nexport const $isSafeInt = Number.isSafeInteger;\nexport const $isFinite = Number.isFinite;\nexport const $MAX_INT = Number.MAX_SAFE_INTEGER;\nexport const $MIN_INT = Number.MIN_SAFE_INTEGER;\n\nexport const $isThenable = (o: any): o is Promise<any> => typeof o?.then === 'function';\n\nexport const $isPrimitive: (o: unknown) => boolean | null | undefined | symbol | number | bigint = (o) =>\n  o === null || (typeof o !== 'object' && typeof o !== 'function');\n\n// # Map\nexport const _getOrInsert = <K, V>(map: Map<K, V>, key: K, value: V): V => {\n  if (!map.has(key)) {\n    map.set(key, value);\n  }\n  return map.get(key)!;\n};\n\nexport const _getOrInsertComputed = <K, V>(map: Map<K, V>, key: K, compute: (key: K) => V): V => {\n  if (!map.has(key)) {\n    map.set(key, compute(key));\n  }\n  return map.get(key)!;\n};\n\n// # WeakMap\nexport const _weakGetOrInsert = <K extends WeakKey, V>(map: WeakMap<K, V>, key: K, value: V): V => {\n  if (!map.has(key)) {\n    map.set(key, value);\n  }\n  return map.get(key)!;\n};\n\nexport const _weakGetOrInsertComputed = <K extends WeakKey, V>(\n  map: WeakMap<K, V>,\n  key: K,\n  compute: (key: K) => V,\n): V => {\n  if (!map.has(key)) {\n    map.set(key, compute(key));\n  }\n  return map.get(key)!;\n};\n","import { _getOrInsertComputed, _getOrInsert } from '@shared';\n\nconst MapConstruct = () => new Map();\n\nexport class DuoMap<K1 = any, K2 = any, V = any> {\n  private map = new Map<K1, Map<K2, V>>();\n\n  get size(): number {\n    let count = 0;\n    this.map.forEach((m) => (count += m.size));\n    return count;\n  }\n\n  set(key1: K1, key2: K2, value: V): this {\n    _getOrInsertComputed(this.map, key1, MapConstruct).set(key2, value);\n    return this;\n  }\n\n  get(key1: K1, key2: K2): V | undefined {\n    return this.map.get(key1)?.get(key2);\n  }\n\n  getOrInsert(key1: K1, key2: K2, value: V): V {\n    const m = _getOrInsertComputed(this.map, key1, MapConstruct);\n    return _getOrInsert(m, key2, value);\n  }\n\n  getOrInsertComputed(key1: K1, key2: K2, compute: (key1: K1, key2: K2) => V): V {\n    const m = _getOrInsertComputed(this.map, key1, MapConstruct);\n    return _getOrInsertComputed(m, key2, () => compute(key1, key2));\n  }\n\n  has(key1: K1, key2: K2): boolean {\n    return this.map.get(key1)?.has(key2) ?? false;\n  }\n\n  delete(key1: K1, key2: K2): boolean {\n    const m = this.map.get(key1);\n    if (!m) {\n      return false;\n    }\n    const result = m.delete(key2);\n    if (m.size === 0) {\n      this.map.delete(key1);\n    }\n    return result;\n  }\n\n  clear(): void {\n    this.map.clear();\n  }\n\n  forEach(callback: (value: V, key1: K1, key2: K2) => void): void {\n    this.map.forEach((m, key1) => m.forEach((value, key2) => callback(value, key1, key2)));\n  }\n\n  keys(): [K1, K2][] {\n    const result: [K1, K2][] = [];\n    this.map.forEach((m, key1) => m.forEach((_, key2) => result.push([key1, key2])));\n    return result;\n  }\n\n  values(): V[] {\n    const result: V[] = [];\n    this.map.forEach((m) => m.forEach((value) => result.push(value)));\n    return result;\n  }\n\n  entries(): [K1, K2, V][] {\n    const result: [K1, K2, V][] = [];\n    this.map.forEach((m, key1) => m.forEach((value, key2) => result.push([key1, key2, value])));\n    return result;\n  }\n\n  [Symbol.iterator](): Iterator<[K1, K2, V]> {\n    const entries = this.entries();\n    let index = 0;\n    return {\n      next(): IteratorResult<[K1, K2, V]> {\n        if (index < entries.length) {\n          return { value: entries[index++], done: false };\n        } else {\n          return { value: undefined as any, done: true };\n        }\n      },\n    };\n  }\n}\n"],"mappings":"mEAGwB,MAAM,QACJ,MAAM,KACT,MAAM,UAAU,OAChB,MAAM,UAAU,OAClB,MAAM,UAAU,KACf,MAAM,UAAU,MACf,MAAM,UAAU,OAGZ,SAAS,UAAU,SAkCxB,OAAO,MACP,OAAO,UACH,OAAO,cACR,OAAO,SAUhC,MAAaA,GAAsB,EAAgB,EAAQ,KACpDC,EAAI,IAAIC,CAAG,GACdD,EAAI,IAAIC,EAAKC,CAAK,EAEbF,EAAI,IAAIC,CAAG,GAGPE,GAA8B,EAAgB,EAAQ,KAC5DH,EAAI,IAAIC,CAAG,GACdD,EAAI,IAAIC,EAAKG,EAAQH,CAAG,CAAC,EAEpBD,EAAI,IAAIC,CAAG,GCpEdI,sBAAqB,IAAI,IAE/B,IAAaC,EAAb,KAAiD,CAC/C,oBAAc,IAAI,IAElB,IAAI,MAAe,CACjB,IAAIC,EAAQ,EAEZ,OADA,KAAK,IAAI,QAAS,GAAO,GAASC,EAAE,IAAK,EAClCD,CACT,CAEA,IAAI,EAAU,EAAU,EAAgB,CAEtC,OADAJ,EAAqB,KAAK,IAAKM,EAAMJ,CAAY,CAAC,CAAC,IAAIK,EAAMR,CAAK,EAC3D,IACT,CAEA,IAAI,EAAU,EAAyB,CACrC,OAAO,KAAK,IAAI,IAAIO,CAAI,CAAC,EAAE,IAAIC,CAAI,CACrC,CAEA,YAAY,EAAU,EAAU,EAAa,CAC3C,IAAMF,EAAIL,EAAqB,KAAK,IAAKM,EAAMJ,CAAY,EAC3D,OAAON,EAAaS,EAAGE,EAAMR,CAAK,CACpC,CAEA,oBAAoB,EAAU,EAAU,EAAuC,CAC7E,IAAMM,EAAIL,EAAqB,KAAK,IAAKM,EAAMJ,CAAY,EAC3D,OAAOF,EAAqBK,EAAGE,MAAYN,EAAQK,EAAMC,CAAI,CAAC,CAChE,CAEA,IAAI,EAAU,EAAmB,CAC/B,OAAO,KAAK,IAAI,IAAID,CAAI,CAAC,EAAE,IAAIC,CAAI,GAAK,EAC1C,CAEA,OAAO,EAAU,EAAmB,CAClC,IAAMF,EAAI,KAAK,IAAI,IAAIC,CAAI,EAC3B,GAAI,CAACD,EACH,MAAO,GAET,IAAMG,EAASH,EAAE,OAAOE,CAAI,EAI5B,OAHIF,EAAE,OAAS,GACb,KAAK,IAAI,OAAOC,CAAI,EAEfE,CACT,CAEA,OAAc,CACZ,KAAK,IAAI,MAAM,CACjB,CAEA,QAAQ,EAAwD,CAC9D,KAAK,IAAI,SAAS,EAAG,IAASH,EAAE,SAAS,EAAO,IAASI,EAASV,EAAOO,EAAMC,CAAI,CAAC,CAAC,CACvF,CAEA,MAAmB,CACjB,IAAMC,EAAqB,CAAC,EAE5B,OADA,KAAK,IAAI,SAAS,EAAG,IAASH,EAAE,SAAS,EAAG,IAASG,EAAO,KAAK,CAACF,EAAMC,CAAI,CAAC,CAAC,CAAC,EACxEC,CACT,CAEA,QAAc,CACZ,IAAMA,EAAc,CAAC,EAErB,OADA,KAAK,IAAI,QAAS,GAAMH,EAAE,QAAS,GAAUG,EAAO,KAAKT,CAAK,CAAC,CAAC,EACzDS,CACT,CAEA,SAAyB,CACvB,IAAMA,EAAwB,CAAC,EAE/B,OADA,KAAK,IAAI,SAAS,EAAG,IAASH,EAAE,SAAS,EAAO,IAASG,EAAO,KAAK,CAACF,EAAMC,EAAMR,CAAK,CAAC,CAAC,CAAC,EACnFS,CACT,CAEA,CAAC,OAAO,WAAmC,CACzC,IAAME,EAAU,KAAK,QAAQ,EACzBC,EAAQ,EACZ,MAAO,CACL,MAAoC,CAIhC,OAHEA,EAAQD,EAAQ,OACX,CAAE,MAAOA,EAAQ,KAAU,KAAM,EAAM,EAEvC,CAAE,MAAO,IAAA,GAAkB,KAAM,EAAK,CAEjD,CACF,CACF,CACF"}

package/dist/index.d.cts

@@ -0,0 +1,20 @@
+//#region src/index.d.ts
+declare class DuoMap<K1 = any, K2 = any, V = any> {
+  private map;
+  get size(): number;
+  set(key1: K1, key2: K2, value: V): this;
+  get(key1: K1, key2: K2): V | undefined;
+  getOrInsert(key1: K1, key2: K2, value: V): V;
+  getOrInsertComputed(key1: K1, key2: K2, compute: (key1: K1, key2: K2) => V): V;
+  has(key1: K1, key2: K2): boolean;
+  delete(key1: K1, key2: K2): boolean;
+  clear(): void;
+  forEach(callback: (value: V, key1: K1, key2: K2) => void): void;
+  keys(): [K1, K2][];
+  values(): V[];
+  entries(): [K1, K2, V][];
+  [Symbol.iterator](): Iterator<[K1, K2, V]>;
+}
+//#endregion
+export { DuoMap };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,20 @@
+//#region src/index.d.ts
+declare class DuoMap<K1 = any, K2 = any, V = any> {
+  private map;
+  get size(): number;
+  set(key1: K1, key2: K2, value: V): this;
+  get(key1: K1, key2: K2): V | undefined;
+  getOrInsert(key1: K1, key2: K2, value: V): V;
+  getOrInsertComputed(key1: K1, key2: K2, compute: (key1: K1, key2: K2) => V): V;
+  has(key1: K1, key2: K2): boolean;
+  delete(key1: K1, key2: K2): boolean;
+  clear(): void;
+  forEach(callback: (value: V, key1: K1, key2: K2) => void): void;
+  keys(): [K1, K2][];
+  values(): V[];
+  entries(): [K1, K2, V][];
+  [Symbol.iterator](): Iterator<[K1, K2, V]>;
+}
+//#endregion
+export { DuoMap };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,2 @@
+Array.isArray,Array.from,Array.prototype.concat,Array.prototype.filter,Array.prototype.push,Array.prototype.slice,Array.prototype.splice,Function.prototype.toString,Number.isNaN,Number.isInteger,Number.isSafeInteger,Number.isFinite;const e=(e,t,n)=>(e.has(t)||e.set(t,n),e.get(t)),t=(e,t,n)=>(e.has(t)||e.set(t,n(t)),e.get(t)),n=()=>/* @__PURE__ */ new Map;var r=class{map=/* @__PURE__ */ new Map;get size(){let e=0;return this.map.forEach(t=>e+=t.size),e}set(e,r,i){return t(this.map,e,n).set(r,i),this}get(e,t){return this.map.get(e)?.get(t)}getOrInsert(r,i,a){let o=t(this.map,r,n);return e(o,i,a)}getOrInsertComputed(e,r,i){let a=t(this.map,e,n);return t(a,r,()=>i(e,r))}has(e,t){return this.map.get(e)?.has(t)??!1}delete(e,t){let n=this.map.get(e);if(!n)return!1;let r=n.delete(t);return n.size===0&&this.map.delete(e),r}clear(){this.map.clear()}forEach(e){this.map.forEach((t,n)=>t.forEach((t,r)=>e(t,n,r)))}keys(){let e=[];return this.map.forEach((t,n)=>t.forEach((t,r)=>e.push([n,r]))),e}values(){let e=[];return this.map.forEach(t=>t.forEach(t=>e.push(t))),e}entries(){let e=[];return this.map.forEach((t,n)=>t.forEach((t,r)=>e.push([n,r,t]))),e}[Symbol.iterator](){let e=this.entries(),t=0;return{next(){return t<e.length?{value:e[t++],done:!1}:{value:void 0,done:!0}}}}};export{r as DuoMap};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["_getOrInsert","map","key","value","_getOrInsertComputed","compute","MapConstruct","DuoMap","count","m","key1","key2","result","callback","entries","index"],"sources":["../../_shared/native/std.ts","../src/index.ts"],"sourcesContent":["// Cached native methods for performance optimization\n\n// # Array\nexport const $isArray = Array.isArray;\nexport const $arrayFrom = Array.from;\nexport const $concat = Array.prototype.concat;\nexport const $filter = Array.prototype.filter;\nexport const $push = Array.prototype.push;\nexport const $slice = Array.prototype.slice;\nexport const $splice = Array.prototype.splice;\n\n// # Object\nexport const $fnToString = Function.prototype.toString;\nexport const $toString = Object.prototype.toString;\nexport const $ObjectPrototype = Object.prototype;\nexport const $is = Object.is;\nexport const $assign = Object.assign;\nexport const $hasOwn = Object.prototype.hasOwnProperty;\nexport const $keys = Object.keys as <T>(o: T) => Array<keyof T>;\nexport const $define = Object.defineProperty;\nexport const $defines = Object.defineProperties;\nexport const $entries = Object.entries as <T>(o: T) => Array<[keyof T, T[keyof T]]>;\nexport const $jsonStringify = JSON.stringify;\nexport const $getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;\nexport const $freeze = Object.freeze;\n\n// # Reflect\n\nexport const $set = Reflect.set;\nexport const $get = Reflect.get;\nexport const $has = Reflect.has;\nexport const $ownKeys = Reflect.ownKeys;\n// & Do not use `Object.defineProperty`\nexport const $reflectDefine = Reflect.defineProperty;\nexport const $delete = Reflect.deleteProperty;\nexport const $getPrototypeOf = Reflect.getPrototypeOf;\nexport const $setPrototypeOf = Reflect.setPrototypeOf;\n\n// # Math and related utilities\nexport const $max = Math.max;\nexport const $min = Math.min;\nexport const $floor = Math.floor;\nexport const $random = Math.random;\nexport const $randomInt = (min: number, max: number) => $floor($random() * (max - min + 1)) + min;\n\n// # Number\nexport const $isNaN = Number.isNaN;\nexport const $isInt = Number.isInteger;\nexport const $isSafeInt = Number.isSafeInteger;\nexport const $isFinite = Number.isFinite;\nexport const $MAX_INT = Number.MAX_SAFE_INTEGER;\nexport const $MIN_INT = Number.MIN_SAFE_INTEGER;\n\nexport const $isThenable = (o: any): o is Promise<any> => typeof o?.then === 'function';\n\nexport const $isPrimitive: (o: unknown) => boolean | null | undefined | symbol | number | bigint = (o) =>\n  o === null || (typeof o !== 'object' && typeof o !== 'function');\n\n// # Map\nexport const _getOrInsert = <K, V>(map: Map<K, V>, key: K, value: V): V => {\n  if (!map.has(key)) {\n    map.set(key, value);\n  }\n  return map.get(key)!;\n};\n\nexport const _getOrInsertComputed = <K, V>(map: Map<K, V>, key: K, compute: (key: K) => V): V => {\n  if (!map.has(key)) {\n    map.set(key, compute(key));\n  }\n  return map.get(key)!;\n};\n\n// # WeakMap\nexport const _weakGetOrInsert = <K extends WeakKey, V>(map: WeakMap<K, V>, key: K, value: V): V => {\n  if (!map.has(key)) {\n    map.set(key, value);\n  }\n  return map.get(key)!;\n};\n\nexport const _weakGetOrInsertComputed = <K extends WeakKey, V>(\n  map: WeakMap<K, V>,\n  key: K,\n  compute: (key: K) => V,\n): V => {\n  if (!map.has(key)) {\n    map.set(key, compute(key));\n  }\n  return map.get(key)!;\n};\n","import { _getOrInsertComputed, _getOrInsert } from '@shared';\n\nconst MapConstruct = () => new Map();\n\nexport class DuoMap<K1 = any, K2 = any, V = any> {\n  private map = new Map<K1, Map<K2, V>>();\n\n  get size(): number {\n    let count = 0;\n    this.map.forEach((m) => (count += m.size));\n    return count;\n  }\n\n  set(key1: K1, key2: K2, value: V): this {\n    _getOrInsertComputed(this.map, key1, MapConstruct).set(key2, value);\n    return this;\n  }\n\n  get(key1: K1, key2: K2): V | undefined {\n    return this.map.get(key1)?.get(key2);\n  }\n\n  getOrInsert(key1: K1, key2: K2, value: V): V {\n    const m = _getOrInsertComputed(this.map, key1, MapConstruct);\n    return _getOrInsert(m, key2, value);\n  }\n\n  getOrInsertComputed(key1: K1, key2: K2, compute: (key1: K1, key2: K2) => V): V {\n    const m = _getOrInsertComputed(this.map, key1, MapConstruct);\n    return _getOrInsertComputed(m, key2, () => compute(key1, key2));\n  }\n\n  has(key1: K1, key2: K2): boolean {\n    return this.map.get(key1)?.has(key2) ?? false;\n  }\n\n  delete(key1: K1, key2: K2): boolean {\n    const m = this.map.get(key1);\n    if (!m) {\n      return false;\n    }\n    const result = m.delete(key2);\n    if (m.size === 0) {\n      this.map.delete(key1);\n    }\n    return result;\n  }\n\n  clear(): void {\n    this.map.clear();\n  }\n\n  forEach(callback: (value: V, key1: K1, key2: K2) => void): void {\n    this.map.forEach((m, key1) => m.forEach((value, key2) => callback(value, key1, key2)));\n  }\n\n  keys(): [K1, K2][] {\n    const result: [K1, K2][] = [];\n    this.map.forEach((m, key1) => m.forEach((_, key2) => result.push([key1, key2])));\n    return result;\n  }\n\n  values(): V[] {\n    const result: V[] = [];\n    this.map.forEach((m) => m.forEach((value) => result.push(value)));\n    return result;\n  }\n\n  entries(): [K1, K2, V][] {\n    const result: [K1, K2, V][] = [];\n    this.map.forEach((m, key1) => m.forEach((value, key2) => result.push([key1, key2, value])));\n    return result;\n  }\n\n  [Symbol.iterator](): Iterator<[K1, K2, V]> {\n    const entries = this.entries();\n    let index = 0;\n    return {\n      next(): IteratorResult<[K1, K2, V]> {\n        if (index < entries.length) {\n          return { value: entries[index++], done: false };\n        } else {\n          return { value: undefined as any, done: true };\n        }\n      },\n    };\n  }\n}\n"],"mappings":"AAGwB,MAAM,QACJ,MAAM,KACT,MAAM,UAAU,OAChB,MAAM,UAAU,OAClB,MAAM,UAAU,KACf,MAAM,UAAU,MACf,MAAM,UAAU,OAGZ,SAAS,UAAU,SAkCxB,OAAO,MACP,OAAO,UACH,OAAO,cACR,OAAO,SAUhC,MAAaA,GAAsB,EAAgB,EAAQ,KACpDC,EAAI,IAAIC,CAAG,GACdD,EAAI,IAAIC,EAAKC,CAAK,EAEbF,EAAI,IAAIC,CAAG,GAGPE,GAA8B,EAAgB,EAAQ,KAC5DH,EAAI,IAAIC,CAAG,GACdD,EAAI,IAAIC,EAAKG,EAAQH,CAAG,CAAC,EAEpBD,EAAI,IAAIC,CAAG,GCpEdI,sBAAqB,IAAI,IAE/B,IAAaC,EAAb,KAAiD,CAC/C,oBAAc,IAAI,IAElB,IAAI,MAAe,CACjB,IAAIC,EAAQ,EAEZ,OADA,KAAK,IAAI,QAAS,GAAO,GAASC,EAAE,IAAK,EAClCD,CACT,CAEA,IAAI,EAAU,EAAU,EAAgB,CAEtC,OADAJ,EAAqB,KAAK,IAAKM,EAAMJ,CAAY,CAAC,CAAC,IAAIK,EAAMR,CAAK,EAC3D,IACT,CAEA,IAAI,EAAU,EAAyB,CACrC,OAAO,KAAK,IAAI,IAAIO,CAAI,CAAC,EAAE,IAAIC,CAAI,CACrC,CAEA,YAAY,EAAU,EAAU,EAAa,CAC3C,IAAMF,EAAIL,EAAqB,KAAK,IAAKM,EAAMJ,CAAY,EAC3D,OAAON,EAAaS,EAAGE,EAAMR,CAAK,CACpC,CAEA,oBAAoB,EAAU,EAAU,EAAuC,CAC7E,IAAMM,EAAIL,EAAqB,KAAK,IAAKM,EAAMJ,CAAY,EAC3D,OAAOF,EAAqBK,EAAGE,MAAYN,EAAQK,EAAMC,CAAI,CAAC,CAChE,CAEA,IAAI,EAAU,EAAmB,CAC/B,OAAO,KAAK,IAAI,IAAID,CAAI,CAAC,EAAE,IAAIC,CAAI,GAAK,EAC1C,CAEA,OAAO,EAAU,EAAmB,CAClC,IAAMF,EAAI,KAAK,IAAI,IAAIC,CAAI,EAC3B,GAAI,CAACD,EACH,MAAO,GAET,IAAMG,EAASH,EAAE,OAAOE,CAAI,EAI5B,OAHIF,EAAE,OAAS,GACb,KAAK,IAAI,OAAOC,CAAI,EAEfE,CACT,CAEA,OAAc,CACZ,KAAK,IAAI,MAAM,CACjB,CAEA,QAAQ,EAAwD,CAC9D,KAAK,IAAI,SAAS,EAAG,IAASH,EAAE,SAAS,EAAO,IAASI,EAASV,EAAOO,EAAMC,CAAI,CAAC,CAAC,CACvF,CAEA,MAAmB,CACjB,IAAMC,EAAqB,CAAC,EAE5B,OADA,KAAK,IAAI,SAAS,EAAG,IAASH,EAAE,SAAS,EAAG,IAASG,EAAO,KAAK,CAACF,EAAMC,CAAI,CAAC,CAAC,CAAC,EACxEC,CACT,CAEA,QAAc,CACZ,IAAMA,EAAc,CAAC,EAErB,OADA,KAAK,IAAI,QAAS,GAAMH,EAAE,QAAS,GAAUG,EAAO,KAAKT,CAAK,CAAC,CAAC,EACzDS,CACT,CAEA,SAAyB,CACvB,IAAMA,EAAwB,CAAC,EAE/B,OADA,KAAK,IAAI,SAAS,EAAG,IAASH,EAAE,SAAS,EAAO,IAASG,EAAO,KAAK,CAACF,EAAMC,EAAMR,CAAK,CAAC,CAAC,CAAC,EACnFS,CACT,CAEA,CAAC,OAAO,WAAmC,CACzC,IAAME,EAAU,KAAK,QAAQ,EACzBC,EAAQ,EACZ,MAAO,CACL,MAAoC,CAIhC,OAHEA,EAAQD,EAAQ,OACX,CAAE,MAAOA,EAAQ,KAAU,KAAM,EAAM,EAEvC,CAAE,MAAO,IAAA,GAAkB,KAAM,EAAK,CAEjD,CACF,CACF,CACF"}

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "duo-map",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1",
+  "author": {
+    "name": "KasukabeTsumugi",
+    "email": "futami16237@gmail.com"
+  },
+  "description": "A duo-key map, mapping two keys to a single value.",
+  "description_zh": "双键映射，由两个key映射到一个值",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "clear && vitest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baendlorel/tsumugi-lib.git",
+    "directory": "packages/duo-map"
+  },
+  "keywords": [
+    "cache",
+    "caching",
+    "typescript",
+    "utility",
+    "javascript",
+    "npm"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/baendlorel/tsumugi-lib/issues"
+  },
+  "homepage": "https://github.com/baendlorel/tsumugi-lib/tree/main/packages/duo-map#readme",
+  "devDependencies": {}
 }