@sixtyninecommerce/admin 0.10.0 → 0.11.0

package/dist/documents/index.js

@@ -1,8 +1,14 @@
 import { createPage, idempotencyKey as mintIdempotencyKey, pageFromVendureList, readOffsetCursor, ValidationError, } from '@sixtyninecommerce/core';
+import { storeCreditAware } from '../payments/store-credit-fields.js';
+import { createArDocumentsModule } from './ar.js';
+import { decodePdf } from './pdf.js';
+// Also what `documents.ar.pdf` decodes with (headless W10-30).
+export { decodePdf };
 const API_DOCUMENT_TYPE = {
     invoice: 'INVOICE',
     'credit-note': 'CREDIT_NOTE',
     'packing-slip': 'PACKING_SLIP',
+    'purchase-order': 'PURCHASE_ORDER',
 };
 /**
  * Most blocks one document may carry. A longer list refuses the whole document
@@ -10,6 +16,12 @@ const API_DOCUMENT_TYPE = {
  * dropped the overflow — a document is a page, not a feed.
  */
 export const MAX_DOCUMENT_EXTENSIONS = 10;
+/** Every {@link DocumentEmailEvent}, in the order the server's enum declares them. */
+export const DOCUMENT_EMAIL_EVENTS = [
+    'invoice_generated',
+    'credit_note_issued',
+    'proforma',
+];
 const DOCUMENT_LINE_FIELDS = /* GraphQL */ `
   description
   sku
@@ -40,6 +52,8 @@ const INVOICE_FIELDS = /* GraphQL */ `
   supplementsInvoiceId
   lines { ${DOCUMENT_LINE_FIELDS} }
   numberingProvider
+  amountPaid
+  amountDue
   createdAt
 `;
 const CREDIT_NOTE_FIELDS = /* GraphQL */ `
@@ -172,8 +186,8 @@ export const ORDER_CREDIT_NOTE_EMAIL_SENDS_QUERY = /* GraphQL */ `
   }
 `;
 export const ISSUE_PARTIAL_CREDIT_NOTE_MUTATION = /* GraphQL */ `
-  mutation IssuePartialCreditNote($input: IssuePartialCreditNoteInput!) {
-    issuePartialCreditNote(input: $input) { ${CREDIT_NOTE_FIELDS} }
+  mutation IssuePartialCreditNote($input: IssuePartialCreditNoteInput!, $idempotencyKey: String) {
+    issuePartialCreditNote(input: $input, idempotencyKey: $idempotencyKey) { ${CREDIT_NOTE_FIELDS} }
   }
 `;
 export const ISSUE_SUPPLEMENTARY_INVOICE_MUTATION = /* GraphQL */ `
@@ -232,9 +246,43 @@ const INVOICE_CORRECTION_PLAN_FIELDS = /* GraphQL */ `
         options { paymentId method amount refundable }
         recommendedPaymentId
       }
-      accountCredit { available unavailableCode message }
+      accountCredit { available unavailableCode message book }
       settlement
       blockers { code message path }
+      returnedGoods {
+        lines {
+          orderLineId
+          description
+          quantity
+          returnedQuantity
+          creditedQuantity
+          creditableQuantity
+          creditableAmount
+          returnCodes
+        }
+        shipping { charged refunded credited creditable returnCodes }
+      }
+      givenBack {
+        lines {
+          orderLineId
+          description
+          quantity
+          returnedQuantity
+          creditedQuantity
+          priceCredited
+          creditableQuantity
+          creditableAmount
+          returnCodes
+          creditNoteNumbers
+        }
+        shipping { charged refunded credited creditable returnCodes creditNoteNumbers }
+      }
+      paymentTerms {
+        invoiced { summary paymentDays conditionCode dueOn }
+        replacement { summary paymentDays conditionCode dueOn }
+        accepts
+        unavailableMessage
+      }
 `;
 export const PLAN_INVOICE_CORRECTION_QUERY = /* GraphQL */ `
   query PlanInvoiceCorrection($input: InvoiceCorrectionInput!) {
@@ -269,7 +317,7 @@ export const COMMIT_INVOICE_CORRECTION_MUTATION = /* GraphQL */ `
         numberingProvider
       }
       refund { id state total paymentId }
-      accountCredit { amount currencyCode unappliedCashIds }
+      accountCredit { amount currencyCode unappliedCashIds book storeCreditEntryIds }
     }
   }
 `;
@@ -288,6 +336,231 @@ export const DELETE_DOCUMENT_EXTENSION_MUTATION = /* GraphQL */ `
     deleteDocumentExtension(key: $key)
   }
 `;
+/**
+ * The invoice config every engine answers. `columnUnitPriceAfterDiscount` arrived after the rest
+ * (2026-10-09), and an engine without it refuses the whole document, so each document has a
+ * `_LEGACY` twin selecting only these, sent once the engine refused the current one.
+ */
+const INVOICE_CONFIG_FIELDS_LEGACY = /* GraphQL */ `
+  id
+  enabled
+  prefix
+  suffix
+  nextNumber
+  digits
+  yearFormat
+  yearReset
+  creditNoteNextNumber
+  creditNotePrefix
+  creditNoteSuffix
+  creditNoteDigits
+  creditNoteYearFormat
+  creditNoteYearReset
+  columnProduct
+  columnSku
+  columnQuantity
+  columnUnitPriceExcl
+  columnUnitPriceDiscount
+  columnUnitPriceIncl
+  columnLineTotal
+  columnLineDiscount
+  columnTaxRate
+  columnTaxAmount
+  columnTotal
+  showLogo
+  legalIdentityBlock
+  footerText
+  defaultLanguage
+  externalNumberOrderField
+  invoicingProvider
+`;
+const INVOICE_CONFIG_FIELDS = /* GraphQL */ `
+  ${INVOICE_CONFIG_FIELDS_LEGACY}
+  columnUnitPriceAfterDiscount
+`;
+export const INVOICE_CONFIG_QUERY = /* GraphQL */ `
+  query InvoiceConfig {
+    invoiceConfig { ${INVOICE_CONFIG_FIELDS} }
+  }
+`;
+export const UPDATE_INVOICE_CONFIG_MUTATION = /* GraphQL */ `
+  mutation UpdateInvoiceConfig($input: UpdateInvoiceConfigInput!) {
+    updateInvoiceConfig(input: $input) { ${INVOICE_CONFIG_FIELDS} }
+  }
+`;
+/** {@link INVOICE_CONFIG_QUERY} for an engine without `columnUnitPriceAfterDiscount`. */
+export const INVOICE_CONFIG_QUERY_LEGACY = /* GraphQL */ `
+  query InvoiceConfig {
+    invoiceConfig { ${INVOICE_CONFIG_FIELDS_LEGACY} }
+  }
+`;
+/** {@link UPDATE_INVOICE_CONFIG_MUTATION} for an engine without `columnUnitPriceAfterDiscount`. */
+export const UPDATE_INVOICE_CONFIG_MUTATION_LEGACY = /* GraphQL */ `
+  mutation UpdateInvoiceConfig($input: UpdateInvoiceConfigInput!) {
+    updateInvoiceConfig(input: $input) { ${INVOICE_CONFIG_FIELDS_LEGACY} }
+  }
+`;
+/** {@link SET_INVOICING_PROVIDER_MUTATION} for an engine without `columnUnitPriceAfterDiscount`. */
+export const SET_INVOICING_PROVIDER_MUTATION_LEGACY = /* GraphQL */ `
+  mutation SetInvoicingProvider($code: String!) {
+    setInvoicingProvider(code: $code) { ${INVOICE_CONFIG_FIELDS_LEGACY} }
+  }
+`;
+export const INVOICING_PROVIDERS_QUERY = /* GraphQL */ `
+  query InvoicingProviders {
+    invoicingProviders {
+      code
+      label
+      external
+      documents
+      ready
+      notReadyReason
+    }
+  }
+`;
+export const SET_INVOICING_PROVIDER_MUTATION = /* GraphQL */ `
+  mutation SetInvoicingProvider($code: String!) {
+    setInvoicingProvider(code: $code) { ${INVOICE_CONFIG_FIELDS} }
+  }
+`;
+const FINANCIAL_DOCUMENT_ISSUE_FIELDS = /* GraphQL */ `
+  id
+  provider
+  operationKey
+  documentType
+  ledger
+  orderId
+  status
+  externalRef
+  externalNumber
+  documentDate
+  attempts
+  lastError
+  reservedAt
+  bookedAt
+  recordedAt
+  abandonReason
+`;
+export const FINANCIAL_DOCUMENT_ISSUES_QUERY = /* GraphQL */ `
+  query FinancialDocumentIssues($unresolvedOnly: Boolean, $take: Int, $skip: Int) {
+    financialDocumentIssues(unresolvedOnly: $unresolvedOnly, take: $take, skip: $skip) {
+      totalItems
+      items { ${FINANCIAL_DOCUMENT_ISSUE_FIELDS} }
+    }
+  }
+`;
+export const ABANDON_FINANCIAL_DOCUMENT_ISSUE_MUTATION = /* GraphQL */ `
+  mutation AbandonFinancialDocumentIssue($id: ID!, $reason: String!) {
+    abandonFinancialDocumentIssue(id: $id, reason: $reason) { ${FINANCIAL_DOCUMENT_ISSUE_FIELDS} }
+  }
+`;
+export const RESOLVE_FINANCIAL_DOCUMENT_ISSUE_MUTATION = /* GraphQL */ `
+  mutation ResolveFinancialDocumentIssue($id: ID!, $reason: String!) {
+    resolveFinancialDocumentIssue(id: $id, reason: $reason) { ${FINANCIAL_DOCUMENT_ISSUE_FIELDS} }
+  }
+`;
+export const SEND_PROFORMA_INVOICE_MUTATION = /* GraphQL */ `
+  mutation SendProformaInvoice($input: SendProformaInvoiceInput!) {
+    sendProformaInvoice(input: $input)
+  }
+`;
+export const ORDER_PROFORMA_SENDS_QUERY = /* GraphQL */ `
+  query OrderProformaSends($orderId: ID!) {
+    orderProformaSends(orderId: $orderId) {
+      id
+      orderId
+      recipients
+      message
+      invoicedOn
+      createdAt
+    }
+  }
+`;
+export const ORDER_INVOICE_EMAIL_SENDS_QUERY = /* GraphQL */ `
+  query OrderInvoiceEmailSends($orderId: ID!) {
+    orderInvoiceEmailSends(orderId: $orderId) {
+      id
+      orderId
+      recipientsTo
+      recipientsCc
+      createdAt
+    }
+  }
+`;
+/** Its own document: `documentEmailRecipients` is new, so on an older engine this call alone fails. */
+export const DOCUMENT_EMAIL_RECIPIENTS_QUERY = /* GraphQL */ `
+  query DocumentEmailRecipients($orderId: ID!, $event: DocumentEmailEvent!) {
+    documentEmailRecipients(orderId: $orderId, event: $event) {
+      to
+      cc
+    }
+  }
+`;
+export const REGENERATE_PACKING_SLIP_MUTATION = /* GraphQL */ `
+  mutation RegeneratePackingSlip($fulfillmentId: ID!, $languageCode: String) {
+    regeneratePackingSlip(fulfillmentId: $fulfillmentId, languageCode: $languageCode) {
+      ${PACKING_SLIP_FIELDS}
+    }
+  }
+`;
+export const PACKING_SLIP_FIELDS_QUERY = /* GraphQL */ `
+  query PackingSlipFulfillmentFields {
+    packingSlipFulfillmentFields {
+      handlerCode
+      handlerName
+      fields {
+        key
+        label
+        type
+        defaultVisible
+      }
+    }
+  }
+`;
+const PACKING_SLIP_CONFIG_FIELDS = /* GraphQL */ `
+  id
+  enabled
+  prefix
+  suffix
+  nextNumber
+  digits
+  yearFormat
+  yearReset
+  columnRowNumber
+  columnProduct
+  columnSku
+  columnQuantity
+  showLogo
+  showInvoiceNumber
+  fulfillmentFieldVisibility
+  footerText
+  defaultLanguage
+`;
+export const PACKING_SLIP_CONFIG_QUERY = /* GraphQL */ `
+  query PackingSlipConfig {
+    packingSlipConfig { ${PACKING_SLIP_CONFIG_FIELDS} }
+  }
+`;
+export const UPDATE_PACKING_SLIP_CONFIG_MUTATION = /* GraphQL */ `
+  mutation UpdatePackingSlipConfig($input: UpdatePackingSlipConfigInput!) {
+    updatePackingSlipConfig(input: $input) { ${PACKING_SLIP_CONFIG_FIELDS} }
+  }
+`;
+/**
+ * Whether a failure is "this engine does not know that field yet": the document refused before it
+ * ran (graphql-js answers a validation failure with HTTP 400 → `BAD_REQUEST`, or coded
+ * `GRAPHQL_VALIDATION_FAILED`), never an execution-time refusal or a transient failure. The
+ * returns module reads the same signs.
+ */
+function isUnknownFieldRejection(error) {
+    if (!(error instanceof ValidationError) || error.service !== 'vendure')
+        return false;
+    return (error.code === 'BAD_REQUEST' ||
+        error.code === 'GRAPHQL_VALIDATION_FAILED' ||
+        /Cannot query field/i.test(error.message));
+}
+/** The server's default page of booking attempts; the SDK states it so the cursor arithmetic knows the size. */
+const ISSUES_PAGE_SIZE = 50;
 /** A complete array behind the SDK's page shape (spec §9.2). */
 function wholeList(items, what) {
     return createPage(items, { nextCursor: null, hasNext: false, total: items.length }, () => {
@@ -322,19 +595,18 @@ function fromApiTypes(values) {
 function toSchema(raw) {
     return { ...raw, documentTypes: fromApiTypes(raw.documentTypes) };
 }
-/** Decode the base64 a PDF-returning mutation answers with. */
-function decodePdf(base64) {
-    // Node and every modern runtime have `atob`; Buffer would tie this package
-    // to Node, and it ships to browsers as the dashboard's client.
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let index = 0; index < binary.length; index += 1) {
-        bytes[index] = binary.charCodeAt(index);
-    }
-    return bytes;
-}
 /** The server's default page; the SDK states it so the cursor arithmetic knows the size. */
 const CUSTOMER_DOCUMENTS_PAGE_SIZE = 25;
+/**
+ * The key a caller retries an attempt under, put on the error the attempt threw (when nothing below
+ * put one there already). Returns the same error.
+ */
+function withAttemptKey(error, key) {
+    if (error !== null && typeof error === 'object' && !('idempotencyKey' in error)) {
+        Object.defineProperty(error, 'idempotencyKey', { value: key, enumerable: true });
+    }
+    return error;
+}
 export function createDocumentsModule(transport) {
     const customerDocumentsPage = async (customerId, skip, take, options) => {
         const data = await transport.graphql({
@@ -346,6 +618,31 @@ export function createDocumentsModule(transport) {
         const items = list.items.map((item) => ({ ...item, type: fromApiType(item.type) }));
         return pageFromVendureList({ items, totalItems: list.totalItems }, skip, take, (cursor) => customerDocumentsPage(customerId, readOffsetCursor(cursor), take, options));
     };
+    /** Latched once the engine proved it predates `columnUnitPriceAfterDiscount` (one refused request per client). */
+    let afterDiscountUnsupported = false;
+    /** Sends the current invoice-config document, or its legacy twin once the engine refused the column. */
+    async function withInvoiceConfigFallback(query, legacy, variables, options) {
+        if (!afterDiscountUnsupported) {
+            try {
+                return await transport.graphql({ api: 'admin', query, variables }, options);
+            }
+            catch (error) {
+                if (!isUnknownFieldRejection(error))
+                    throw error;
+            }
+        }
+        const data = await transport.graphql({ api: 'admin', query: legacy, variables }, options);
+        afterDiscountUnsupported = true;
+        return data;
+    }
+    const issuesPage = async (skip, take, options) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: FINANCIAL_DOCUMENT_ISSUES_QUERY,
+            variables: { unresolvedOnly: options?.unresolvedOnly ?? false, take, skip },
+        }, options);
+        return pageFromVendureList(data.financialDocumentIssues, skip, take, (cursor) => issuesPage(readOffsetCursor(cursor), take, options));
+    };
     return {
         // One implementation behind the two overloads the interface declares; the
         // cast is the standard TypeScript shape for that, since an implementation
@@ -460,17 +757,31 @@ export function createDocumentsModule(transport) {
             return wholeList(data.orderCreditNoteEmailSends, 'orderCreditNoteEmailSends');
         },
         async issuePartialCreditNote(input, options) {
-            const data = await transport.graphql({ api: 'admin', query: ISSUE_PARTIAL_CREDIT_NOTE_MUTATION, variables: { input } }, options);
-            return data.issuePartialCreditNote;
+            const key = options?.idempotencyKey ?? mintIdempotencyKey();
+            try {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: ISSUE_PARTIAL_CREDIT_NOTE_MUTATION,
+                    // A retry of this attempt sends the same input under the same key.
+                    variables: { input, idempotencyKey: key },
+                }, { ...options, idempotencyKey: key });
+                return { ...data.issuePartialCreditNote, idempotencyKey: key };
+            }
+            catch (error) {
+                throw withAttemptKey(error, key);
+            }
         },
         async planCorrection(input, options) {
-            const data = await transport.graphql({ api: 'admin', query: PLAN_INVOICE_CORRECTION_QUERY, variables: { input } }, options);
+            // `book` (incentives sprint 8 PR 4): dropped once for an engine before it.
+            const data = await storeCreditAware(transport).graphql({ api: 'admin', query: PLAN_INVOICE_CORRECTION_QUERY, variables: { input } }, options);
             return data.planInvoiceCorrection;
         },
         async commitCorrection(input, options) {
             const key = options.idempotencyKey ?? mintIdempotencyKey();
             try {
-                const data = await transport.graphql({
+                // `book` and `storeCreditEntryIds` (sprint 8 PR 4): an engine before them refuses the
+                // document before it runs, and it is sent once more without them under the same key.
+                const data = await storeCreditAware(transport).graphql({
                     api: 'admin',
                     query: COMMIT_INVOICE_CORRECTION_MUTATION,
                     // The input goes out as given, never normalised: it must be the request the plan was
@@ -480,17 +791,118 @@ export function createDocumentsModule(transport) {
                 return { ...data.commitInvoiceCorrection, idempotencyKey: key };
             }
             catch (error) {
-                // The key the caller retries under, when it did not choose one.
-                if (error !== null && typeof error === 'object' && !('idempotencyKey' in error)) {
-                    Object.defineProperty(error, 'idempotencyKey', { value: key, enumerable: true });
-                }
-                throw error;
+                throw withAttemptKey(error, key);
             }
         },
         async issueSupplementaryInvoice(input, options) {
             const data = await transport.graphql({ api: 'admin', query: ISSUE_SUPPLEMENTARY_INVOICE_MUTATION, variables: { input } }, options);
             return data.issueSupplementaryInvoice;
         },
+        async sendProforma(orderId, input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SEND_PROFORMA_INVOICE_MUTATION,
+                variables: {
+                    input: {
+                        orderId,
+                        invoicedOn: input.invoicedOn,
+                        recipients: input.recipients,
+                        message: input.message ?? null,
+                        languageCode: input.languageCode ?? null,
+                    },
+                },
+            }, options);
+            return data.sendProformaInvoice;
+        },
+        async proformaSends(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_PROFORMA_SENDS_QUERY, variables: { orderId } }, options);
+            return wholeList(data.orderProformaSends, 'orderProformaSends');
+        },
+        async invoiceEmailSends(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_INVOICE_EMAIL_SENDS_QUERY, variables: { orderId } }, options);
+            return wholeList(data.orderInvoiceEmailSends, 'orderInvoiceEmailSends');
+        },
+        async emailRecipients(orderId, event, options) {
+            if (!DOCUMENT_EMAIL_EVENTS.includes(event)) {
+                throw new ValidationError({
+                    code: 'INVALID_DOCUMENT_EMAIL_EVENT',
+                    message: `"${String(event)}" is not a document email. Expected one of ${DOCUMENT_EMAIL_EVENTS.join(', ')}.`,
+                    status: 400,
+                    service: 'vendure',
+                });
+            }
+            const data = await transport.graphql({ api: 'admin', query: DOCUMENT_EMAIL_RECIPIENTS_QUERY, variables: { orderId, event } }, options);
+            return data.documentEmailRecipients;
+        },
+        async regeneratePackingSlip(fulfillmentId, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: REGENERATE_PACKING_SLIP_MUTATION,
+                variables: { fulfillmentId, languageCode: options?.languageCode ?? null },
+            }, options);
+            return data.regeneratePackingSlip;
+        },
+        async packingSlipFields(options) {
+            const data = await transport.graphql({ api: 'admin', query: PACKING_SLIP_FIELDS_QUERY }, options);
+            return wholeList(data.packingSlipFulfillmentFields, 'packingSlipFulfillmentFields');
+        },
+        invoiceConfig: {
+            async get(options) {
+                const data = await withInvoiceConfigFallback(INVOICE_CONFIG_QUERY, INVOICE_CONFIG_QUERY_LEGACY, {}, options);
+                return data.invoiceConfig;
+            },
+            async update(input, options) {
+                // Validation refuses the document before anything runs, so the legacy send is the first
+                // attempt, never a repeat.
+                const data = await withInvoiceConfigFallback(UPDATE_INVOICE_CONFIG_MUTATION, UPDATE_INVOICE_CONFIG_MUTATION_LEGACY, { input }, options);
+                return data.updateInvoiceConfig;
+            },
+        },
+        invoicingProviders: {
+            async list(options) {
+                const data = await transport.graphql({ api: 'admin', query: INVOICING_PROVIDERS_QUERY }, options);
+                return wholeList(data.invoicingProviders, 'invoicingProviders');
+            },
+            async set(provider, options) {
+                const data = await withInvoiceConfigFallback(SET_INVOICING_PROVIDER_MUTATION, SET_INVOICING_PROVIDER_MUTATION_LEGACY, { code: provider }, options);
+                return data.setInvoicingProvider;
+            },
+        },
+        issues: {
+            list(options) {
+                // The Admin API is offset-paged; the offset hides inside the cursor (spec §9.3).
+                const take = options?.limit ?? ISSUES_PAGE_SIZE;
+                const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+                return issuesPage(skip, take, options);
+            },
+            async abandon(id, reason, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: ABANDON_FINANCIAL_DOCUMENT_ISSUE_MUTATION,
+                    variables: { id, reason },
+                }, options);
+                return data.abandonFinancialDocumentIssue;
+            },
+            async resolve(id, reason, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: RESOLVE_FINANCIAL_DOCUMENT_ISSUE_MUTATION,
+                    variables: { id, reason },
+                }, options);
+                return data.resolveFinancialDocumentIssue;
+            },
+        },
+        packingSlipConfig: {
+            async get(options) {
+                const data = await transport.graphql({ api: 'admin', query: PACKING_SLIP_CONFIG_QUERY }, options);
+                return data.packingSlipConfig;
+            },
+            async update(input, options) {
+                const data = await transport.graphql({ api: 'admin', query: UPDATE_PACKING_SLIP_CONFIG_MUTATION, variables: { input } }, options);
+                return data.updatePackingSlipConfig;
+            },
+        },
+        ar: createArDocumentsModule(transport),
         extensions: {
             async list(options) {
                 const data = await transport.graphql({ api: 'admin', query: DOCUMENT_EXTENSIONS_QUERY }, options);

package/dist/documents/pdf.d.ts

@@ -0,0 +1,2 @@
+/** Decode the base64 a PDF-returning call answers with (`documents.previewInvoice`, `documents.ar.pdf`). */
+export declare function decodePdf(base64: string): Uint8Array;

package/dist/documents/pdf.js

@@ -0,0 +1,11 @@
+/** Decode the base64 a PDF-returning call answers with (`documents.previewInvoice`, `documents.ar.pdf`). */
+export function decodePdf(base64) {
+    // Node and every modern runtime have `atob`; Buffer would tie this package
+    // to Node, and it ships to browsers as the dashboard's client.
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}