@icure/api 4.1.10 → 4.1.11

package/icc-x-api/icc-receipt-x-api.ts

@@ -0,0 +1,96 @@
+import { IccReceiptApi } from '../icc-api'
+import { IccCryptoXApi } from './icc-crypto-x-api'
+import * as _ from 'lodash'
+import * as models from '../icc-api/model/models'
+
+export class IccReceiptXApi extends IccReceiptApi {
+  constructor(
+    host: string,
+    headers: { [key: string]: string },
+    private crypto: IccCryptoXApi,
+    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
+      ? window.fetch
+      : typeof self !== 'undefined'
+      ? self.fetch
+      : fetch
+  ) {
+    super(host, headers, fetchImpl)
+  }
+
+  newInstance(user: models.User, r: any): Promise<models.Receipt> {
+    const receipt = new models.Receipt(
+      _.extend(
+        {
+          id: this.crypto.randomUuid(),
+          _type: 'org.taktik.icure.entities.Receipt',
+          created: new Date().getTime(),
+          modified: new Date().getTime(),
+          responsible: user.healthcarePartyId || user.patientId,
+          author: user.id,
+          codes: [],
+          tags: [],
+        },
+        r || {}
+      )
+    )
+
+    return this.initDelegationsAndEncryptionKeys(user, receipt)
+  }
+
+  private initDelegationsAndEncryptionKeys(user: models.User, receipt: models.Receipt): Promise<models.Receipt> {
+    return Promise.all([
+      this.crypto.initObjectDelegations(receipt, null, (user.healthcarePartyId || user.patientId)!, null),
+      this.crypto.initEncryptionKeys(receipt, (user.healthcarePartyId || user.patientId)!),
+    ]).then((initData) => {
+      const dels = initData[0]
+      const eks = initData[1]
+      _.extend(receipt, {
+        delegations: dels.delegations,
+        cryptedForeignKeys: dels.cryptedForeignKeys,
+        secretForeignKeys: dels.secretForeignKeys,
+        encryptionKeys: eks.encryptionKeys,
+      })
+
+      let promise = Promise.resolve(receipt)
+      ;(user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : []).forEach(
+        (delegateId) =>
+          (promise = promise.then((receipt) =>
+            this.crypto
+              .addDelegationsAndEncryptionKeys(null, receipt, (user.healthcarePartyId || user.patientId)!, delegateId, dels.secretId, eks.secretId)
+              .catch((e) => {
+                console.log(e)
+                return receipt
+              })
+          ))
+      )
+      return promise
+    })
+  }
+
+  initEncryptionKeys(user: models.User, rcpt: models.Receipt) {
+    return this.crypto.initEncryptionKeys(rcpt, (user.healthcarePartyId || user.patientId)!).then((eks) => {
+      let promise = Promise.resolve(
+        _.extend(rcpt, {
+          encryptionKeys: eks.encryptionKeys,
+        })
+      )
+      ;(user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : []).forEach(
+        (delegateId) =>
+          (promise = promise.then((receipt) =>
+            this.crypto.appendEncryptionKeys(receipt, (user.healthcarePartyId || user.patientId)!, delegateId, eks.secretId).then((extraEks) => {
+              return _.extend(receipt, {
+                encryptionKeys: extraEks.encryptionKeys,
+              })
+            })
+          ))
+      )
+      return promise
+    })
+  }
+
+  logReceipt(user: models.User, docId: string, refs: Array<string>, blobType: string, blob: ArrayBuffer) {
+    return this.newInstance(user, { documentId: docId, references: refs })
+      .then((rcpt) => this.createReceipt(rcpt))
+      .then((rcpt) => (blob.byteLength != 0 ? this.setReceiptAttachment(rcpt.id!, blobType, '', <any>blob) : Promise.resolve(rcpt)))
+  }
+}

package/icc-x-api/icc-time-table-x-api.ts

@@ -0,0 +1,63 @@
+import * as i18n from './rsrc/contact.i18n'
+
+import * as _ from 'lodash'
+import { IccTimeTableApi } from '../icc-api'
+import { User } from '../icc-api/model/User'
+import { TimeTable } from '../icc-api/model/TimeTable'
+import { IccCryptoXApi } from './icc-crypto-x-api'
+
+export class IccTimeTableXApi extends IccTimeTableApi {
+  i18n: any = i18n
+  crypto: IccCryptoXApi
+
+  constructor(
+    host: string,
+    headers: { [key: string]: string },
+    crypto: IccCryptoXApi,
+    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
+      ? window.fetch
+      : typeof self !== 'undefined'
+      ? self.fetch
+      : fetch
+  ) {
+    super(host, headers, fetchImpl)
+    this.crypto = crypto
+  }
+
+  newInstance(user: User, tt: TimeTable) {
+    const timeTable = _.extend(
+      {
+        id: this.crypto.randomUuid(),
+        _type: 'org.taktik.icure.entities.TimeTable',
+        created: new Date().getTime(),
+        modified: new Date().getTime(),
+        responsible: user.healthcarePartyId || user.patientId,
+        author: user.id,
+        codes: [],
+        tags: [],
+      },
+      tt || {}
+    )
+
+    return this.crypto.initObjectDelegations(timeTable, null, (user.healthcarePartyId || user.patientId)!, null).then((initData) => {
+      _.extend(timeTable, { delegations: initData.delegations })
+
+      let promise = Promise.resolve(timeTable)
+      ;(user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : []).forEach(
+        (delegateId) =>
+          (promise = promise
+            .then((patient) =>
+              this.crypto.extendedDelegationsAndCryptedForeignKeys(
+                patient,
+                null,
+                (user.healthcarePartyId || user.patientId)!,
+                delegateId,
+                initData.secretId
+              )
+            )
+            .then((extraData) => _.extend(timeTable, { delegations: extraData.delegations })))
+      )
+      return promise
+    })
+  }
+}

package/icc-x-api/icc-user-x-api.ts

@@ -0,0 +1,19 @@
+import { IccUserApi } from '../icc-api/api/IccUserApi'
+import { b2a } from './utils/binary-utils'
+
+export class IccUserXApi extends IccUserApi {
+  fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response>
+
+  constructor(
+    host: string,
+    headers: { [key: string]: string },
+    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
+      ? window.fetch
+      : typeof self !== 'undefined'
+      ? self.fetch
+      : fetch
+  ) {
+    super(host, headers, fetchImpl)
+    this.fetchImpl = fetchImpl
+  }
+}

package/icc-x-api/index.ts

@@ -0,0 +1,122 @@
+import { IccAgendaApi, IccAuthApi, IccEntityrefApi, IccGroupApi, IccInsuranceApi, IccPatientApi } from '../icc-api'
+import { IccUserXApi } from './icc-user-x-api'
+import { IccCryptoXApi } from './icc-crypto-x-api'
+import { IccContactXApi } from './icc-contact-x-api'
+import { IccInvoiceXApi } from './icc-invoice-x-api'
+import { IccDocumentXApi } from './icc-document-x-api'
+import { IccHcpartyXApi } from './icc-hcparty-x-api'
+import { IccFormXApi } from './icc-form-x-api'
+import { IccHelementXApi } from './icc-helement-x-api'
+import { IccClassificationXApi } from './icc-classification-x-api'
+import { IccCalendarItemXApi } from './icc-calendar-item-x-api'
+import { IccPatientXApi } from './icc-patient-x-api'
+import { IccMessageXApi } from './icc-message-x-api'
+import { IccReceiptXApi } from './icc-receipt-x-api'
+import { IccAccesslogXApi } from './icc-accesslog-x-api'
+import { IccTimeTableXApi } from './icc-time-table-x-api'
+import { IccDeviceApi } from '../icc-api/api/IccDeviceApi'
+import { IccCodeXApi } from './icc-code-x-api'
+
+export * from './icc-accesslog-x-api'
+export * from './icc-bekmehr-x-api'
+export * from './icc-calendar-item-x-api'
+export * from './icc-classification-x-api'
+export * from './icc-code-x-api'
+export * from './icc-contact-x-api'
+export * from './icc-crypto-x-api'
+export * from './icc-doctemplate-x-api'
+export * from './icc-document-x-api'
+export * from './icc-form-x-api'
+export * from './icc-hcparty-x-api'
+export * from './icc-helement-x-api'
+export * from './icc-invoice-x-api'
+export * from './icc-message-x-api'
+export * from './icc-patient-x-api'
+export * from './icc-user-x-api'
+export * from './icc-time-table-x-api'
+export * from './icc-receipt-x-api'
+export { utils, UtilsClass } from './crypto/utils'
+export * from './utils'
+
+export const apiHeaders = function (username: string, password: string) {
+  return {
+    Authorization: `Basic ${
+      typeof btoa !== 'undefined' ? btoa(`${username}:${password}`) : Buffer.from(`${username}:${password}`).toString('base64')
+    }`,
+  }
+}
+
+export const Api = function (
+  host: string,
+  username: string,
+  password: string,
+  crypto: Crypto = typeof window !== 'undefined' ? window.crypto : typeof self !== 'undefined' ? self.crypto : ({} as Crypto),
+  fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
+    ? window.fetch
+    : typeof self !== 'undefined'
+    ? self.fetch
+    : fetch
+) {
+  const headers = apiHeaders(username, password)
+  const authApi = new IccAuthApi(host, headers, fetchImpl)
+  const codeApi = new IccCodeXApi(host, headers, fetchImpl)
+  const entityReferenceApi = new IccEntityrefApi(host, headers, fetchImpl)
+  const userApi = new IccUserXApi(host, headers, fetchImpl)
+  const healthcarePartyApi = new IccHcpartyXApi(host, headers, fetchImpl)
+  const deviceApi = new IccDeviceApi(host, headers, fetchImpl)
+  const cryptoApi = new IccCryptoXApi(host, headers, healthcarePartyApi, new IccPatientApi(host, headers, fetchImpl), deviceApi, crypto)
+  const accessLogApi = new IccAccesslogXApi(host, headers, cryptoApi, fetchImpl)
+  const agendaApi = new IccAgendaApi(host, headers, fetchImpl)
+  const contactApi = new IccContactXApi(host, headers, cryptoApi, fetchImpl)
+  const formApi = new IccFormXApi(host, headers, cryptoApi, fetchImpl)
+  const groupApi = new IccGroupApi(host, headers)
+  const invoiceApi = new IccInvoiceXApi(host, headers, cryptoApi, entityReferenceApi, fetchImpl)
+  const insuranceApi = new IccInsuranceApi(host, headers, fetchImpl)
+  const documentApi = new IccDocumentXApi(host, headers, cryptoApi, authApi, fetchImpl)
+  const healthcareElementApi = new IccHelementXApi(host, headers, cryptoApi, fetchImpl)
+  const classificationApi = new IccClassificationXApi(host, headers, cryptoApi, fetchImpl)
+  const calendarItemApi = new IccCalendarItemXApi(host, headers, cryptoApi, fetchImpl)
+  const receiptApi = new IccReceiptXApi(host, headers, cryptoApi, fetchImpl)
+  const timetableApi = new IccTimeTableXApi(host, headers, cryptoApi, fetchImpl)
+  const patientApi = new IccPatientXApi(
+    host,
+    headers,
+    cryptoApi,
+    contactApi,
+    formApi,
+    healthcareElementApi,
+    invoiceApi,
+    documentApi,
+    healthcarePartyApi,
+    classificationApi,
+    calendarItemApi,
+    ['note'],
+    fetchImpl
+  )
+  const messageApi = new IccMessageXApi(host, headers, cryptoApi, fetchImpl)
+
+  return {
+    cryptoApi,
+    authApi,
+    codeApi,
+    userApi,
+    patientApi,
+    healthcarePartyApi,
+    deviceApi,
+    accessLogApi,
+    contactApi,
+    healthcareElementApi,
+    documentApi,
+    formApi,
+    invoiceApi,
+    insuranceApi,
+    messageApi,
+    entityReferenceApi,
+    receiptApi,
+    agendaApi,
+    calendarItemApi,
+    classificationApi,
+    timetableApi,
+    groupApi,
+  }
+}

package/icc-x-api/rsrc/codelng.ts

@@ -0,0 +1,8 @@
+export default {
+  'BE-THESAURUS': ['fr', 'nl'],
+  'CD-ATC': ['fr', 'nl'],
+  'CD-DRUG-CNK': ['fr', 'nl'],
+  'CD-INNCLUSTER': ['fr', 'nl'],
+  ICPC: ['fr', 'nl'],
+  ICD: ['fr', 'nl'],
+}

package/icc-x-api/rsrc/contact.i18n.ts

@@ -0,0 +1,110 @@
+export default {
+  fr: {
+    package: 'boîte',
+    packages: 'boîtes',
+    packageOf: 'boîte de',
+    packagesOf: 'boîtes de',
+    during: 'pendant',
+    take_s_: 'prise(s)',
+    weekly: '/semaine',
+    monthly: '/mois',
+    daily: '/jour',
+    the: 'le',
+    onDay: 'le jour',
+    on: 'le',
+    afterwakingup: 'Au lever',
+    afterbreakfast: 'Après ptit déj.',
+    afterdinner: 'Après rep. soir',
+    afterlunch: 'Après rep. midi',
+    afternoon: 'Après-midi',
+    beforebreakfast: 'Avant ptit déj.',
+    beforedinner: 'Avant rep. soir',
+    beforelunch: 'Avant rep. midi',
+    duringbreakfast: 'Pdt ptit déj.',
+    duringdinner: 'Pdt rep. soir',
+    duringlunch: 'Pdt rep. midi',
+    betweenbreakfastandlunch: 'Entre ptit déj et rep. midi',
+    betweenlunchanddinner: 'Entre rep. midi et rep. soir',
+    betweendinnerandsleep: 'Entre rep. soir et couch.',
+    evening: 'Soir',
+    knownuse: 'Usage connu',
+    morning: 'Matin',
+    night: 'Avt couch.',
+    midday: 'Midi',
+    noon: 'Midi',
+    at: 'à',
+    thehourofsleep: 'Au coucher',
+  },
+  en: {
+    package: 'package',
+    packages: 'packages',
+    packageOf: 'package of',
+    packagesOf: 'packages of',
+    during: 'during',
+    take_s_: 'take(s)',
+    weekly: 'weekly',
+    monthly: 'monthly',
+    daily: 'daily',
+    the: 'the',
+    onDay: 'on day',
+    on: 'on',
+    afterwakingup: 'After Waking Up',
+    afterbreakfast: 'After Breakfast',
+    afterdinner: 'After Dinner',
+    afterlunch: 'After Lunch',
+    afternoon: 'Afternoon',
+    beforebreakfast: 'Before Breakfast',
+    beforedinner: 'Before Dinner',
+    beforelunch: 'Before Lunch',
+    duringbreakfast: 'During Breakfast',
+    duringdinner: 'During Dinner',
+    duringlunch: 'During Lunch',
+    betweenbreakfastandlunch: 'Between Breakfast and Lunch',
+    betweenlunchanddinner: 'Between Lunch and Dinner',
+    betweendinnerandsleep: 'Between Dinner and Sleep',
+    evening: 'Evening',
+    knownuse: 'Known Usage',
+    morning: 'Morning',
+    night: 'Night',
+    midday: 'Midday',
+    noon: 'Noon',
+    at: 'at',
+    thehourofsleep: 'At Bedtime',
+  },
+  nl: {
+    package: 'verpakking',
+    packages: 'verpakkingen',
+    packageOf: 'verpakking van',
+    packagesOf: 'verpakkingen van',
+    during: 'gedurende',
+    take_s_: 'inname(s)',
+    weekly: 'wekelijks',
+    monthly: 'maandelijks',
+    daily: 'dagelijks',
+    the: 'de',
+    onDay: 'op dag',
+    on: 'op',
+    afterwakingup: 'Bij het opstaan',
+    afterbreakfast: 'Na ontbijt',
+    afterdinner: 'Na avondeten',
+    afterlunch: 'Na middageten',
+    afternoon: 'Namiddag',
+    beforebreakfast: 'Voor ontbijt',
+    beforedinner: 'Voor avondeten',
+    beforelunch: 'Voor middageten',
+    duringbreakfast: 'Tijdens ontbijt',
+    duringdinner: 'Tijdens avondeten',
+    duringlunch: 'Tijdens middageten',
+    betweenbreakfastandlunch: 'Tussen ontbijt en middageten',
+    betweenlunchanddinner: 'Tussen middag- en avondeten',
+    betweendinnerandsleep: 'Tussen avondmaal en slapeneten',
+    evening: 'Avond',
+    knownuse: 'Gekend gebruik',
+    morning: "'s Morgens",
+    night: 'Vóór slapengaan',
+    midday: 'Middag',
+    noon: 'Middag',
+    at: 'om',
+    thehourofsleep: 'Voor het slapen',
+  },
+}

package/icc-x-api/rsrc/icd10.ts

@@ -0,0 +1,113 @@
+export default {
+  'A00-B99': {
+    en: 'Infectious and parasitic',
+    fr: 'Infections & parasites',
+    colour: 'ICD-10--IV',
+  },
+  'C00-D48': {
+    en: 'Neoplasms',
+    fr: 'Tumeurs',
+    colour: 'ICD-10--IV',
+  },
+  'D49-D89': {
+    en: 'Blood & immunity',
+    fr: 'Sang & immunité',
+    colour: 'ICD-10--IV',
+  },
+  'E00-E99': {
+    en: 'Endocrine, nutritional & metabolic',
+    fr: 'Endocrino, nutrition et métabolisme',
+    colour: 'ICD-10--IV',
+  },
+  'F00-F99': {
+    en: 'Mental and behavioural disorders',
+    fr: 'Troubles mentaux et du comportement',
+    colour: 'ICD-10--V',
+  },
+  'G00-G99': {
+    en: 'Nervous system',
+    fr: 'Système nerveux',
+    colour: 'ICD-10--VI',
+  },
+  'H00-H59': {
+    en: 'Eye and adnexa',
+    fr: 'Œil et de ses annexes',
+    colour: 'ICD-10--VII',
+  },
+  'H60-H99': {
+    en: 'Ear and mastoid process',
+    fr: "Oreille et de l'apophyse mastoïde",
+    colour: 'ICD-10--VII',
+  },
+  'I00-I99': {
+    en: 'Circulatory system',
+    fr: 'Appareil circulatoire',
+    colour: 'ICD-10--VIII',
+  },
+  'J00-J99': {
+    en: 'Respiratory system',
+    fr: 'Appareil respiratoire',
+    colour: 'ICD-10--IX',
+  },
+  'K00-K99': {
+    en: 'Digestive system',
+    fr: 'Appareil digestif',
+    colour: 'ICD-10--X',
+  },
+  'L00-L99': {
+    en: 'Skin and subcutaneous tissue',
+    fr: 'Peau et Tissu cellulaire sous-cutané',
+    colour: 'ICD-10--XI',
+  },
+  'M00-M99': {
+    en: 'Musculoskeletal system and connective tissue',
+    fr: 'Système ostéo-articulaire, des muscles et du tissu conjonctif',
+    colour: 'ICD-10--XII',
+  },
+  'N00-N99': {
+    en: 'Genitourinary system',
+    fr: 'Appareil génito-urinaire',
+    colour: 'ICD-10--XIII',
+  },
+  'O00-O99': {
+    en: 'Pregnancy, childbirth and the puerperium',
+    fr: 'Grossesse, accouchement et puerpéralité',
+    colour: 'ICD-10--XIV',
+  },
+  'P00-P99': {
+    en: 'Perinatal period conditions',
+    fr: 'Affections périnatale',
+    colour: 'ICD-10--XV',
+  },
+  'Q00-Q99': {
+    en: 'Congenital malformations, deformations and chromosomal abnormalities',
+    fr: 'Malformations congénitales et anomalies chromosomiques',
+    colour: 'ICD-10--XVI',
+  },
+  'R00-R69': {
+    en: 'Symptoms and signs',
+    fr: 'Symptômes et signes',
+    colour: 'ICD-10--other',
+  },
+  'R70-R94': {
+    en: 'Abnormal clinical and laboratory findings',
+    fr: 'Examens cliniques et laboratoires anormaux',
+    colour: 'ICD-10--other',
+  },
+  'R95-R99': {
+    en: 'Ill-defined and unknown causes of mortality',
+    fr: 'Cause de décès mal-définie ou inconnue',
+    colour: 'ICD-10--other',
+  },
+  'S00-T99': {
+    en: 'Injuries & poisoning',
+    fr: 'Traumato & toxicologie',
+    colour: 'ICD-10--other',
+  },
+  'U00-Y99': { en: 'Unsorted', fr: 'Non-classé', colour: 'ICD-10--other' },
+  'Z00-Z99': {
+    en: 'General health status',
+    fr: 'Etat général',
+    colour: 'ICD-10--other',
+  },
+}

package/icc-x-api/rsrc/icpc2.ts

@@ -0,0 +1,22 @@
+export default {
+  A: { en: 'General and unspecified', colour: 'ICPC-2--A' },
+  B: {
+    en: 'Blood, blood forming organs, lymphatics, spleen',
+    colour: 'ICPC-2--B',
+  },
+  D: { en: 'Digestive', colour: 'ICPC-2--D' },
+  F: { en: 'Eye', colour: 'ICPC-2--F' },
+  H: { en: 'Ear', colour: 'ICPC-2--H' },
+  K: { en: 'Circulatory', colour: 'ICPC-2--K' },
+  L: { en: 'Musculoskeletal', colour: 'ICPC-2--L' },
+  N: { en: 'Neurological', colour: 'ICPC-2--N' },
+  P: { en: 'Psychological', colour: 'ICPC-2--P' },
+  R: { en: 'Respiratory', colour: 'ICPC-2--R' },
+  S: { en: 'Skin', colour: 'ICPC-2--S' },
+  T: { en: 'Endocrine, metabolic and nutritional', colour: 'ICPC-2--T' },
+  U: { en: 'Urology', colour: 'ICPC-2--U' },
+  W: { en: 'Pregnancy, childbirth, family planning', colour: 'ICPC-2--W' },
+  X: { en: 'Female genital system and breast', colour: 'ICPC-2--X' },
+  Y: { en: 'Male genital system', colour: 'ICPC-2--Y' },
+  Z: { en: 'Social problems', colour: 'ICPC-2--Z' },
+}

package/icc-x-api/utils/asn1-packer.ts

@@ -0,0 +1,87 @@
+// Copyright 2018 AJ ONeal. All rights reserved
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Ported to Typescript by iCure sa */
+
+const numToHex = function (d: number): string {
+  const ds = d.toString(16)
+  if (ds.length % 2) {
+    return '0' + ds
+  }
+  return ds
+}
+
+//
+// Packer
+//
+// Almost every ASN.1 type that's important for CSR
+// can be represented generically with only a few rules.
+export function packOther(...args: string[]) {
+  const typ: string = args.shift()!
+  const str: string = args.join('').replace(/\s+/g, '').toLowerCase()
+  var len: number = str.length / 2
+  var lenlen = 0
+  var hex = typ
+
+  // We can't have an odd number of hex chars
+  if (len !== Math.round(len)) {
+    throw new Error('invalid hex')
+  }
+
+  // The first byte of any ASN.1 sequence is the type (Sequence, Integer, etc)
+  // The second byte is either the size of the value, or the size of its size
+  // 1. If the second byte is < 0x80 (128) it is considered the size
+  // 2. If it is > 0x80 then it describes the number of bytes of the size
+  //    ex: 0x82 means the next 2 bytes describe the size of the value
+  // 3. The special case of exactly 0x80 is "indefinite" length (to end-of-file)
+  if (len > 127) {
+    lenlen += 1
+    while (len > 255) {
+      lenlen += 1
+      len = len >> 8
+    }
+  }
+
+  if (lenlen) {
+    hex += numToHex(0x80 + lenlen)
+  }
+  return hex + numToHex(str.length / 2) + str
+}
+
+// The Integer type has some special rules
+function packUInt(...arr: string[]) {
+  const str = arr.join('')
+  const first = parseInt(str.slice(0, 2), 16)
+
+  // If the first byte is 0x80 or greater, the number is considered negative
+  // Therefore we add a '00' prefix if the 0x80 bit is set
+  return 0x80 & first ? packOther('02', '00' + str) : packOther('02', str)
+}
+
+// The Bit String type also has a special rule
+function packBitStr(...arr: string[]) {
+  var str = arr.join('')
+  // '00' is a mask of how many bits of the next byte to ignore
+  return packOther('03', '00' + str)
+}
+
+export type Asn1Item = number | string | Asn1Item[]
+
+export function pack(arr: Asn1Item[]) {
+  var typ = numToHex(arr[0] as number)
+  var str = ''
+  if (arr[1]) {
+    if (Array.isArray(arr[1])) {
+      arr[1].forEach((a) => (str += pack(a as Asn1Item[])))
+    } else if ('string' === typeof arr[1]) {
+      str = arr[1]
+    } else {
+      throw new Error('unexpected item')
+    }
+  }
+  const packed = '03' === typ ? packBitStr(str) : '02' === typ ? packUInt(str) : packOther(typ, str)
+
+  return packed
+}