@wener/utils 1.1.46 → 1.1.48

package/src/cn/id/ResidentIdNumber.ts

@@ -1,7 +1,7 @@
-import { Mod11Checksum } from './Mod11Checksum';
+import { Mod11 } from './Mod11';
 
-export class ResidentIdNumber {
-  checksum = Mod11Checksum.get();
+class ResidentIdNumberFormat {
+  checksum = Mod11;
 
   // 9 https://zh.wikipedia.org/wiki/中华人民共和国外国人永久居留身份证
   // 9 标识码
@@ -11,19 +11,15 @@ export class ResidentIdNumber {
   regex =
     /^(?<division>[1-9]\d{5})(?<year>18|19|20)\d{2}(?<month>0[1-9]|1[0-2])(?<day>0[1-9]|[12]\d|3[01])(?<sequence>\d{3})(?<checksum>[0-9Xx])$/;
 
-  private static instance: ResidentIdNumber;
-
-  static get() {
-    return (this.instance ||= new ResidentIdNumber());
-  }
-
-  verify(s: string) {
+  validate(s: string) {
     if (!s) return false;
-    return this.regex.test(s) && this.checksum.verify(s.toUpperCase());
+    return this.regex.test(s) && this.checksum.validate(s.toUpperCase());
   }
 
+  generate(opts: { sex?: 'Male' | 'Female'; age?: number; birthDate?: Date; division?: string }) {}
+
   parse(s: string): IdNumber | undefined {
-    if (!this.verify(s)) {
+    if (!this.validate(s)) {
       return;
     }
 
@@ -86,7 +82,7 @@ class IdNumber {
   }
 
   get valid() {
-    return ResidentIdNumber.get().verify(this.toString());
+    return ResidentIdNumber.validate(this.toString());
   }
 
   get male() {
@@ -126,3 +122,5 @@ function formatDate(date: Date, format = 'YYYYMMDD') {
       throw new Error(`Invalid format`);
   }
 }
+
+export const ResidentIdNumber = new ResidentIdNumberFormat();

package/src/cn/id/id.test.ts

@@ -1,19 +1,19 @@
 import { assert, expect, test } from 'vitest';
-import { Mod11Checksum } from './Mod11Checksum';
+import { Mod11 } from './Mod11';
 import { ResidentIdNumber } from './ResidentIdNumber';
 
 test('id', (t) => {
   const ids = ['11010519491231002X', '11010219840406970X'];
 
-  let cs = Mod11Checksum.get();
+  let cs = Mod11;
   for (const id of ids) {
     assert.equal(cs.generate(id.slice(0, -1)), id.at(-1));
   }
 
-  let parse = ResidentIdNumber.get().parse(ids[0]);
-  expect(parse?.toObject()).toEqual({
+  let parse = ResidentIdNumber.parse(ids[0]);
+  expect(parse?.toObject()).toMatchObject({
     division: '110105',
-    date: new Date('1949-12-31'),
+    birthDate: new Date('1949-12-31'),
     sequence: 2,
     checksum: 'X',
   });

package/src/cn/scripts/gen.test.ts

@@ -15,7 +15,8 @@ test(
     timeout: 1000 * 60 * 30,
   },
   async () => {
-    await generate();
+    // missing parent 4419003 for 441900003001
+    // await generate();
   },
 );
 

package/src/cn/uscc/{Mod31Checksum.ts → Mod31.ts}

@@ -14,12 +14,6 @@ export class Mod31Checksum {
     {} as Record<string, number>,
   );
 
-  private static instance: Mod31Checksum;
-
-  static get() {
-    return this.instance || (this.instance = new Mod31Checksum());
-  }
-
   toChar(n: number) {
     return this.chars[n];
   }
@@ -28,7 +22,7 @@ export class Mod31Checksum {
     return this.numbers[c];
   }
 
-  verify(s: string) {
+  validate(s: string) {
     return s.at(-1) === this.generate(s.slice(0, s.length - 1));
   }
 
@@ -40,3 +34,5 @@ export class Mod31Checksum {
     return this.toChar(31 - (sum % 31));
   }
 }
+
+export const Mod31 = new Mod31Checksum();

package/src/cn/uscc/USCC.ts

@@ -1,4 +1,4 @@
-import { Mod31Checksum } from './Mod31Checksum';
+import { Mod31 } from './Mod31';
 
 /**
  * - GB 32100-2015 法人和其他组织统一社会信用代码编码规则
@@ -8,7 +8,7 @@ import { Mod31Checksum } from './Mod31Checksum';
  *
  * @see https://en.wikipedia.org/wiki/Unified_Social_Credit_Identifier
  */
-export class USCC {
+export class UnifiedSocialCreditCodeFormat {
   registryCodeLabels: Record<string, Code> = {
     1: {
       label: '机构编制',
@@ -47,13 +47,7 @@ export class USCC {
 
   /* 16 位 */
   regex = /^([159][1239]|Y1)[0-9]{6}[0-9A-HJ-NP-RTUWXY]{10}$/; // 无 I O Z S V
-  checksum = Mod31Checksum.get();
-
-  static instance: USCC;
-
-  static get() {
-    return (this.instance ||= new USCC());
-  }
+  checksum = Mod31;
 
   parse(s: string): ParsedUSCC {
     let registryCode = s[0];
@@ -71,8 +65,8 @@ export class USCC {
     };
   }
 
-  verify(s: string) {
-    return this.regex.test(s) && this.checksum.verify(s);
+  validate(s: string) {
+    return this.regex.test(s) && this.checksum.validate(s);
   }
 }
 
@@ -96,3 +90,5 @@ interface ParsedUSCC {
   // 校验码
   checksum: string;
 }
+
+export const USCC = new UnifiedSocialCreditCodeFormat();

package/src/cn/uscc/isUSCC.ts

@@ -4,5 +4,5 @@ import { USCC } from './USCC';
  * USCC - 统一社会信用代码
  */
 export function isUSCC(s: string) {
-  return USCC.get().verify(s);
+  return USCC.validate(s);
 }

package/src/cn/uscc/uscc.test.ts

@@ -1,16 +1,16 @@
 import { expect, test } from 'vitest';
 import { isUSCC } from './isUSCC';
-import { Mod31Checksum } from './Mod31Checksum';
+import { Mod31 } from './Mod31';
 import { USCC } from './USCC';
 
 test('uscc', () => {
-  let cs = Mod31Checksum.get();
+  let cs = Mod31;
 
   // 阿里云计算
-  expect(cs.verify('91330106673959654P')).toBeTruthy();
+  expect(cs.validate('91330106673959654P')).toBeTruthy();
   expect(cs.generate('91330106673959654')).toBe('P');
 
   expect(isUSCC('91330106673959654P')).toBeTruthy();
 
-  console.log(USCC.get().parse('91330106673959654P'));
+  console.log(USCC.parse('91330106673959654P'));
 });

package/src/crypto/getNodeCrypto.ts

@@ -1,17 +1,21 @@
-let nodeCrypto: Awaited<typeof import('node:crypto')>;
+import { getGlobalThis } from '../runtime/getGlobalThis';
+
+let nodeCrypto;
 // globalThis.process?.release?.name
 
+// avoid import node
 // avoid process.browser
-if (typeof window === 'undefined') {
-  try {
-    // avoid `node:` UnhandledSchemeError https://github.com/vercel/next.js/issues/28774
-    if (typeof require === 'undefined') {
-      void import('crypto').then((v) => (nodeCrypto = v.default));
-    } else {
-      nodeCrypto = require('crypto');
-    }
-  } catch (e) {}
-}
+// if (typeof window === 'undefined') {
+//   try {
+//     // avoid `node:` UnhandledSchemeError https://github.com/vercel/next.js/issues/28774
+//     if (typeof require === 'undefined') {
+//       void import('crypto').then((v) => (nodeCrypto = v.default));
+//     } else {
+//       nodeCrypto = require('crypto');
+//     }
+//   } catch (e) {}
+// }
 export function getNodeCrypto() {
+  nodeCrypto ||= getGlobalThis().crypto;
   return nodeCrypto;
 }

package/src/crypto/getRandomValues.ts

@@ -4,10 +4,15 @@ import { getGlobalThis } from '../runtime/getGlobalThis';
 import { getNodeCrypto } from './getNodeCrypto';
 
 const globalThis = getGlobalThis();
+
+// chrome 11+, safari 5+, nodejs 17.4+
+// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
 export let getRandomValues: <T extends Exclude<TypedArray, Float32Array | Float64Array>>(typedArray: T) => T =
   globalThis.crypto?.getRandomValues?.bind(globalThis.crypto) ||
   (globalThis as any).msCrypto?.getRandomValues?.bind((globalThis as any).msCrypto) ||
-  _getRandomValues;
+  (() => {
+    throw new Error('[getRandomValues]: No secure random number generator available.');
+  });
 
 function _getRandomValues<T extends Exclude<TypedArray, Float32Array | Float64Array>>(buf: T) {
   const nodeCrypto = getNodeCrypto();

package/src/emitter/types.ts

@@ -0,0 +1,18 @@
+export type EventType = string | symbol;
+
+export type Handler<E extends keyof T, T = Record<string, unknown>> = (evt: { type: E; payload: T[E] }) => void;
+export type WildcardHandler<T = Record<string, unknown>> = <E extends keyof T>(evt: { type: E; payload: T[E] }) => void;
+
+export interface Emitter<Events extends Record<EventType, unknown>> {
+  on<Key extends keyof Events>(type: Key, handler: Handler<Key, Events>): void;
+
+  on(type: '*', handler: WildcardHandler<Events>): void;
+
+  off<Key extends keyof Events>(type: Key, handler?: Handler<Key, Events>): void;
+
+  off(type: '*', handler: WildcardHandler<Events>): void;
+
+  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+
+  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}

package/src/fetch/http.types.ts

@@ -0,0 +1,46 @@
+// from hono
+
+export type InfoStatusCode = 100 | 101 | 102 | 103;
+export type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+export type DeprecatedStatusCode = 305 | 306;
+export type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+export type ClientErrorStatusCode =
+  | 400
+  | 401
+  | 402
+  | 403
+  | 404
+  | 405
+  | 406
+  | 407
+  | 408
+  | 409
+  | 410
+  | 411
+  | 412
+  | 413
+  | 414
+  | 415
+  | 416
+  | 417
+  | 418
+  | 421
+  | 422
+  | 423
+  | 424
+  | 425
+  | 426
+  | 428
+  | 429
+  | 431
+  | 451;
+export type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+
+export type UnofficialStatusCode = -1;
+export type StatusCode =
+  | InfoStatusCode
+  | SuccessStatusCode
+  | RedirectStatusCode
+  | ClientErrorStatusCode
+  | ServerErrorStatusCode
+  | UnofficialStatusCode;

package/src/index.ts

@@ -1,3 +1,5 @@
+import { Promises } from './asyncs/Promises';
+
 // arrays
 export {
   firstOfMaybeArray,
@@ -25,10 +27,10 @@ export { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator';
 export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator';
 export { isIterator } from './asyncs/isIterator';
 
-export { sleep } from './asyncs/sleep';
+export { Promises } from './asyncs/Promises';
+export const sleep = Promises.sleep;
+export const isPromise = Promises.isPromise;
 export { timeout, TimeoutError } from './asyncs/timeout';
-export { isPromise } from './asyncs/isPromise';
-// export * from './async/promiseOfCallback';
 
 // langs
 export { shallowEqual } from './langs/shallowEqual';

package/src/io/ArrayBuffers.ts

@@ -157,18 +157,23 @@ export class ArrayBuffers {
     return this.toUint8Array(ArrayBuffers.from(v, 'hex'));
   };
 
-  static resize = (v: ArrayBufferLike, newByteLength?: number) => {
+  static resize = (v: ArrayBufferLike, newByteLength?: number, maxByteLength?: number): ArrayBuffer => {
     if (newByteLength === undefined || newByteLength === null) {
       return v;
     }
 
-    if ('resize' in v && (v as any).resizable) {
-      (v as any).resize(newByteLength);
-      return v;
+    // Chrome 111, Nodejs 20
+    if ('resize' in v && typeof v.resize === 'function') {
+      if ('resizable' in v && v.resizable) {
+        if ('maxByteLength' in v && typeof v.maxByteLength === 'number' && v.maxByteLength >= newByteLength) {
+          v.resize(newByteLength);
+          return v;
+        }
+      }
     }
 
     const old = v;
-    const newBuf = new ArrayBuffer(newByteLength);
+    const newBuf = new ArrayBuffer(newByteLength, { maxByteLength: maxByteLength });
     const oldView = new Uint8Array(old);
     const newView = new Uint8Array(newBuf);
     newView.set(oldView);

package/src/io/ByteBuffer.test.ts

@@ -2,13 +2,34 @@ import { assert, test } from 'vitest';
 import { ByteBuffer } from './ByteBuffer';
 
 test('ByteBuffer', async () => {
-  let buf = new ByteBuffer();
-  buf.writeString('Hello');
-  buf.writeString('World');
-  assert.equal(buf.length, 10);
-  assert.equal(buf.position, 10);
-  buf.length = 5;
-  assert.equal(buf.length, 5);
-  buf.position = 0;
-  assert.equal(buf.readString(5), 'Hello');
+  {
+    let buf = new ByteBuffer();
+    buf.writeString('Hello');
+    buf.writeString('World');
+    assert.equal(buf.length, 10);
+    assert.equal(buf.position, 10);
+    buf.length = 5;
+    assert.equal(buf.length, 5);
+    buf.position = 0;
+    assert.equal(buf.readString(5), 'Hello');
+  }
+  {
+    // overflow max length
+    let buf = new ByteBuffer();
+    buf.writeBytes(new Uint8Array(1025));
+  }
+  {
+    // overflow max length
+    let buf = new ByteBuffer();
+    buf.writeBytes(new Uint8Array([1, 2]));
+    buf.position = 0;
+    console.log('X', buf.position, buf.length, buf.remaining());
+
+    // truncate to size fill zero
+    buf.writeBytes(new Uint8Array(1), 10);
+    console.log('X', buf.position, buf.length, buf.remaining());
+
+    assert.equal(buf.view.getInt8(1), 2);
+    assert.equal(buf.length, 10);
+  }
 });

package/src/io/ByteBuffer.ts

@@ -1,4 +1,3 @@
-import { isDefined } from '../langs/isDefined';
 import { ArrayBuffers } from './ArrayBuffers';
 
 type AnyBuffer = BufferSource | ArrayBufferLike;
@@ -72,20 +71,12 @@ export class ByteBuffer {
 
   private willWrite(length: number) {
     if (this.remaining() < length) {
-      this.resize(this.length + length);
+      this.resize(this.position + length);
     }
   }
 
   resize(newLength: number) {
-    // Chrome 111, Nodejs 20
-    let buf = this.buffer;
-    if (buf.resize && (!isDefined(buf.resizable) || buf.resizable)) {
-      buf.resize(newLength);
-    } else {
-      let newBuffer = new ArrayBuffer(newLength);
-      new Uint8Array(newBuffer).set(new Uint8Array(buf));
-      this.buffer = newBuffer;
-    }
+    this.buffer = ArrayBuffers.resize(this.buffer, newLength, Math.ceil(newLength * 1.2));
   }
 
   writeByte(value: number) {
@@ -97,7 +88,7 @@ export class ByteBuffer {
     this.willWrite(len);
     if (len !== bytes.byteLength) bytes = bytes.slice(0, len);
     new Uint8Array(this.buffer).set(new Uint8Array(bytes), this.position);
-    this.position += bytes.byteLength;
+    this.position += len;
   }
 
   writeInt8(value: number) {
@@ -333,7 +324,7 @@ export class ByteBuffer {
   }
 
   remaining() {
-    return this.view.byteLength - this.position;
+    return this.length - this.position;
   }
 
   toUint8Array() {

package/src/langs/mixin.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from 'vitest';
+import { mixin } from './mixin';
+
+export type Constructor<T = {}> = new (...args: any[]) => T;
+
+test('mixin', () => {
+  class User extends mixin(BaseResource, createBarFields()) {}
+
+  let usr = new User();
+  // type not working
+  expect(usr.foo, 'foo');
+  expect(usr).toEqual({
+    foo: 'foo',
+    bar: 'bar',
+    id: '',
+  });
+});
+
+class BaseResource {
+  id?: string = '';
+}
+
+function createBarFields() {
+  return <TBase extends Constructor>(Base: TBase) => {
+    class HasBarMixin extends mixin(Base, withFooFields) {
+      bar?: string = 'bar';
+    }
+
+    return HasBarMixin;
+  };
+}
+
+function withFooFields<TBase extends Constructor>(Base: TBase) {
+  class HasFieldFooMixin extends Base {
+    foo?: string = 'foo';
+  }
+
+  return HasFieldFooMixin;
+}

package/src/maths/random.ts

@@ -1,6 +1,6 @@
 /// javascript pseudo random
 export function createRandom(o: { seed?: string | number } = {}) {
-  let seed = typeof o.seed === 'string' ? 0 : o.seed ?? 0;
+  let seed = typeof o.seed === 'string' ? 0 : (o.seed ?? 0);
   if (typeof o.seed === 'string') {
     let sum = 0;
     for (let i = 0; i < o.seed.length; i++) {

package/src/mitt/README.md

@@ -0,0 +1 @@
+- https://github.com/developit/mitt/blob/main/src/index.ts

package/src/mitt/index.ts

@@ -0,0 +1,114 @@
+export type EventType = string | symbol;
+
+type EventPayload<T = EventType, E = unknown> = { type: T; event: E };
+
+export type Handler<T = EventType, E = unknown> = (evt: { type: T; event: E }) => void;
+
+// An array of all currently registered event handlers for a type
+export type EventHandlerList<T = unknown> = Array<Handler<EventType, T>>;
+
+// A map of event types and their corresponding event handlers.
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
+  keyof Events | '*',
+  EventHandlerList<Events[keyof Events]>
+>;
+
+export interface Emitter<Events extends Record<EventType, unknown>> {
+  all: EventHandlerMap<Events>;
+
+  on<Key extends keyof Events>(type: Key, handler: Handler<Key, Events[Key]>): void;
+
+  on(type: '*', handler: Handler<Events>): void;
+
+  once<Key extends keyof Events>(type: Key, handler: Handler<Key, Events[Key]>): void;
+
+  once(type: '*', handler: Handler<Events>): void;
+
+  off<Key extends keyof Events>(type: Key, handler?: Handler<Key, Events[Key]>): void;
+
+  off(type: '*', handler: Handler<Events>): void;
+
+  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+
+  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}
+
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name createEmitter
+ * @returns {Emitter}
+ */
+export default function createEmitter<Events extends Record<EventType, unknown>>(
+  all?: EventHandlerMap<Events>,
+): Emitter<Events> {
+  type GenericEventHandler = Handler<EventType, Events[keyof Events]>;
+  all = all || new Map();
+  let evt: Emitter<Events>;
+  return (evt = {
+    /**
+     * A Map of event names to registered handler functions.
+     */
+    all,
+
+    on(type: EventType, handler: GenericEventHandler) {
+      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all!.set(type, [handler]);
+      }
+    },
+
+    once(type: EventType, handler: GenericEventHandler) {
+      let fn = handler;
+      handler = (...args) => {
+        evt.off(type, fn);
+        fn(...args);
+      };
+      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all!.set(type, [handler]);
+      }
+    },
+
+    off(type: EventType, handler?: GenericEventHandler) {
+      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
+      if (handlers) {
+        if (handler) {
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        } else {
+          all!.set(type, []);
+        }
+      }
+    },
+
+    /**
+     * Invoke all handlers for the given type.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     * @memberOf createEmitter
+     */
+    emit(type: EventType, evt?: any) {
+      let handlers = all!.get(type);
+      let ctx: EventPayload = { type, event: evt };
+      if (handlers) {
+        (handlers as EventHandlerList).slice().map((handler) => {
+          handler(ctx);
+        });
+      }
+
+      handlers = all!.get('*');
+      if (handlers) {
+        (handlers as EventHandlerList).slice().map((handler) => {
+          handler(ctx);
+        });
+      }
+    },
+  } as Emitter<Events>);
+}

package/src/objects/computeIfAbsent.ts

@@ -1,7 +1,8 @@
+export function computeIfAbsent<K extends WeakKey, V>(map: WeakMap<K, V>, key: K, fn: () => V): V;
 export function computeIfAbsent<K, V>(map: Map<K, V>, key: K, fn: () => V): V;
 export function computeIfAbsent<K extends string | symbol | number, V>(map: Record<K, V>, key: K, fn: () => V): V;
-export function computeIfAbsent<K, V>(map: any, key: K, fn: () => V): V {
-  if (map instanceof Map) {
+export function computeIfAbsent(map: any, key: any, fn: () => any): any {
+  if (map instanceof Map || map instanceof WeakMap) {
     if (!map.has(key)) {
       map.set(key, fn());
     }

package/lib/asyncs/sleep.js

@@ -1,3 +0,0 @@
-export const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
-
-//# sourceMappingURL=sleep.js.map

package/lib/asyncs/sleep.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/asyncs/sleep.ts"],"sourcesContent":["export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));\n"],"names":["sleep","ms","Promise","resolve","setTimeout"],"rangeMappings":"","mappings":"AAAA,OAAO,MAAMA,QAAQ,CAACC,KAAe,IAAIC,QAAQ,CAACC,UAAYC,WAAWD,SAASF,KAAK"}

package/lib/cn/id/Mod11Checksum.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/cn/id/Mod11Checksum.ts"],"sourcesContent":["/**\n * ISO 7064:1983, MOD 11-2.\n */\nexport class Mod11Checksum {\n  weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1];\n  private static instance: Mod11Checksum;\n\n  static get() {\n    return this.instance || (this.instance = new Mod11Checksum());\n  }\n\n  verify(s: string) {\n    return s.at(-1) === this.generate(s.slice(0, s.length - 1));\n  }\n\n  generate(s: string) {\n    const { weights } = this;\n    let sum = 0;\n    for (let i = 0; i < s.length; i++) {\n      sum += parseInt(s[i]) * weights[i];\n    }\n    const num = (12 - (sum % 11)) % 11;\n    if (num < 10) {\n      return num.toString();\n    } else {\n      return 'X';\n    }\n  }\n}\n"],"names":["Mod11Checksum","weights","instance","get","verify","s","at","generate","slice","length","sum","i","parseInt","num","toString"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;CAEC,GACD,OAAO,MAAMA;IACXC,UAAU;QAAC;QAAG;QAAG;QAAI;QAAG;QAAG;QAAG;QAAG;QAAG;QAAG;QAAG;QAAG;QAAG;QAAI;QAAG;QAAG;QAAG;QAAG;KAAE,CAAC;IACnE,OAAeC,SAAwB;IAEvC,OAAOC,MAAM;QACX,OAAO,IAAI,CAACD,QAAQ,IAAK,CAAA,IAAI,CAACA,QAAQ,GAAG,IAAIF,eAAc;IAC7D;IAEAI,OAAOC,CAAS,EAAE;QAChB,OAAOA,EAAEC,EAAE,CAAC,CAAC,OAAO,IAAI,CAACC,QAAQ,CAACF,EAAEG,KAAK,CAAC,GAAGH,EAAEI,MAAM,GAAG;IAC1D;IAEAF,SAASF,CAAS,EAAE;QAClB,MAAM,EAAEJ,OAAO,EAAE,GAAG,IAAI;QACxB,IAAIS,MAAM;QACV,IAAK,IAAIC,IAAI,GAAGA,IAAIN,EAAEI,MAAM,EAAEE,IAAK;YACjCD,OAAOE,SAASP,CAAC,CAACM,EAAE,IAAIV,OAAO,CAACU,EAAE;QACpC;QACA,MAAME,MAAM,AAAC,CAAA,KAAMH,MAAM,EAAE,IAAK;QAChC,IAAIG,MAAM,IAAI;YACZ,OAAOA,IAAIC,QAAQ;QACrB,OAAO;YACL,OAAO;QACT;IACF;AACF"}

package/lib/cn/uscc/Mod31Checksum.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/cn/uscc/Mod31Checksum.ts"],"sourcesContent":["/**\n * GB/T 17710（采ISO 7064）的模31校验码\n *\n * Mod31-3\n */\nexport class Mod31Checksum {\n  weights = [1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28];\n  chars = '0123456789ABCDEFGHJKLMNPQRTUWXY';\n  numbers: Record<string, number> = this.chars.split('').reduce(\n    (acc, cur, i) => {\n      acc[cur] = i;\n      return acc;\n    },\n    {} as Record<string, number>,\n  );\n\n  private static instance: Mod31Checksum;\n\n  static get() {\n    return this.instance || (this.instance = new Mod31Checksum());\n  }\n\n  toChar(n: number) {\n    return this.chars[n];\n  }\n\n  toNumber(c: string) {\n    return this.numbers[c];\n  }\n\n  verify(s: string) {\n    return s.at(-1) === this.generate(s.slice(0, s.length - 1));\n  }\n\n  generate(s: string) {\n    let sum = 0;\n    for (let i = 0; i < s.length; i++) {\n      sum += this.numbers[s[i]] * this.weights[i];\n    }\n    return this.toChar(31 - (sum % 31));\n  }\n}\n"],"names":["Mod31Checksum","weights","chars","numbers","split","reduce","acc","cur","i","instance","get","toChar","n","toNumber","c","verify","s","at","generate","slice","length","sum"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;CAIC,GACD,OAAO,MAAMA;IACXC,UAAU;QAAC;QAAG;QAAG;QAAG;QAAI;QAAI;QAAI;QAAI;QAAI;QAAI;QAAI;QAAI;QAAI;QAAG;QAAI;QAAI;QAAI;KAAG,CAAC;IAC3EC,QAAQ,kCAAkC;IAC1CC,UAAkC,IAAI,CAACD,KAAK,CAACE,KAAK,CAAC,IAAIC,MAAM,CAC3D,CAACC,KAAKC,KAAKC;QACTF,GAAG,CAACC,IAAI,GAAGC;QACX,OAAOF;IACT,GACA,CAAC,GACD;IAEF,OAAeG,SAAwB;IAEvC,OAAOC,MAAM;QACX,OAAO,IAAI,CAACD,QAAQ,IAAK,CAAA,IAAI,CAACA,QAAQ,GAAG,IAAIT,eAAc;IAC7D;IAEAW,OAAOC,CAAS,EAAE;QAChB,OAAO,IAAI,CAACV,KAAK,CAACU,EAAE;IACtB;IAEAC,SAASC,CAAS,EAAE;QAClB,OAAO,IAAI,CAACX,OAAO,CAACW,EAAE;IACxB;IAEAC,OAAOC,CAAS,EAAE;QAChB,OAAOA,EAAEC,EAAE,CAAC,CAAC,OAAO,IAAI,CAACC,QAAQ,CAACF,EAAEG,KAAK,CAAC,GAAGH,EAAEI,MAAM,GAAG;IAC1D;IAEAF,SAASF,CAAS,EAAE;QAClB,IAAIK,MAAM;QACV,IAAK,IAAIb,IAAI,GAAGA,IAAIQ,EAAEI,MAAM,EAAEZ,IAAK;YACjCa,OAAO,IAAI,CAAClB,OAAO,CAACa,CAAC,CAACR,EAAE,CAAC,GAAG,IAAI,CAACP,OAAO,CAACO,EAAE;QAC7C;QACA,OAAO,IAAI,CAACG,MAAM,CAAC,KAAMU,MAAM;IACjC;AACF"}

package/src/asyncs/sleep.ts

@@ -1 +0,0 @@
-export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));