es-git 0.5.0-next.171 → 0.5.0-next.172

package/index.d.ts

@@ -2407,7 +2407,7 @@ export declare class Reflog {
    * ```
    *
    * @param {number} i - Index of the entry to remove.
-   * @param {boolean} [rewritePreviousEntry] - Whether to rewrite the previous entry. Defaults to 'false'.
+   * @param {boolean} [rewritePreviousEntry] - Whether to rewrite the previous entry. Defaults to `false`.
    * @throws Throws error if the index is invalid or if removal fails.
    */
   remove(i: number, rewritePreviousEntry?: boolean | undefined | null): void
@@ -2470,6 +2470,7 @@ export declare class Reflog {
    * ```
    *
    * @returns Iterator over the reflog entries.
+   * @throws Throws error if the reflog cannot be accessed.
    */
   iter(): ReflogIter
   /**
@@ -2544,7 +2545,7 @@ export declare class ReflogEntry {
    * @signature
    * ```ts
    * class ReflogEntry {
-   *   message(): string | null;
+   *   message(): string;
    * }
    * ```
    *
@@ -4765,6 +4766,179 @@ export declare class Repository {
    * @returns A container for a list of status information about a repository.
    */
   statuses(): Statuses
+  /**
+   * Set up a new git submodule for checkout.
+   *
+   * This does "git submodule add" up to the fetch and checkout of the
+   * submodule contents. It preps a new submodule, creates an entry in
+   * `.gitmodules` and creates an empty initialized repository either at the
+   * given path in the working directory or in `.git/modules` with a gitlink
+   * from the working directory to the new repo.
+   *
+   * To fully emulate "git submodule add" call this function, then `open()`
+   * the submodule repo and perform the clone step as needed. Lastly, call
+   * `addFinalize()` to wrap up adding the new submodule and `.gitmodules`
+   * to the index to be ready to commit.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submodule(
+   *     url: string,
+   *     path: string,
+   *     useGitlink?: boolean | null | undefined,
+   *   ): Submodule;
+   * }
+   * ```
+   *
+   * @param {string} url - URL for the submodule's remote.
+   * @param {string} path - Path at which the submodule should be created.
+   * @param {boolean} [useGitlink] - Should workdir contain a gitlink to the repo in
+   * `.git/modules` vs. repo directly in workdir.
+   *
+   * @returns The submodule.
+   */
+  submodule(url: string, path: string, useGitlink?: boolean | undefined | null): Submodule
+  submodules(): Array<Submodule>
+  /**
+   * Lookup submodule information by name or path.
+   *
+   * Given either the submodule name or path (they are usually the same),
+   * this returns a structure describing the submodule.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getSubmodule(name: string): Submodule;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of or path to the submodule; trailing slashes okay.
+   * @returns The submodule.
+   * @throws If the submodule not found.
+   */
+  getSubmodule(name: string): Submodule
+  /**
+   * Lookup submodule information by name or path.
+   *
+   * Given either the submodule name or path (they are usually the same),
+   * this returns a structure describing the submodule.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   findSubmodule(name: string): Submodule | null;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of or path to the submodule; trailing slashes okay.
+   * @returns The submodule. Returns `null` if the submodule is not found.
+   */
+  findSubmodule(name: string): Submodule | null
+  /**
+   * Get the status for a submodule.
+   *
+   * This looks at a submodule and tries to determine the status.  It
+   * will return a combination of the `SubmoduleStatus` values.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleStatus(name: string, ignore: SubmoduleIgnore): number;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule.
+   * @param {SubmoduleIgnore} ignore - The ignore rules to follow.
+   * @returns The combination of the `SubmoduleStatus` values.
+   *
+   * @example
+   * ```ts
+   * import { openRepository, submoduleStatusContains, SubmoduleStatus } from 'es-git';
+   *
+   * const repo = await openRepository('...');
+   * const status = repo.submoduleStatus('mysubmodule', 'None');
+   *
+   * console.log(
+   *   submoduleStatusContains(status, SubmoduleStatus.InHead | SubmoduleStatus.InIndex)
+   * ); // true
+   * ```
+   */
+  submoduleStatus(name: string, ignore: SubmoduleIgnore): number
+  /**
+   * Set the ignore rule for the submodule in the configuration
+   *
+   * This does not affect any currently-loaded instances.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleSetIgnore(name: string, ignore: SubmoduleIgnore): void;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule.
+   * @param {SubmoduleIgnore} ignore - The new value for the ignore rule.
+   */
+  submoduleSetIgnore(name: string, ignore: SubmoduleIgnore): void
+  /**
+   * Set the update rule for the submodule in the configuration
+   *
+   * This setting won't affect any existing instances.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleSetUpdate(name: string, update: SubmoduleUpdate): void;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule.
+   * @param {SubmoduleUpdate} update - The new value to use.
+   */
+  submoduleSetUpdate(name: string, update: SubmoduleUpdate): void
+  /**
+   * Set the URL for the submodule in the configuration
+   *
+   * After calling this, you may wish to call `Submodule#sync()` to write
+   * the changes to the checked out submodule repository.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleSetUrl(name: string, url: string): void;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule to configure.
+   * @param {string} url - URL that should be used for the submodule.
+   */
+  submoduleSetUrl(name: string, url: string): void
+  /**
+   * Set the branch for the submodule in the configuration
+   *
+   * After calling this, you may wish to call `Submodule#sync()` to write
+   * the changes to the checked out submodule repository.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleSetBranch(name: string, branchName: string): void;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule to configure.
+   * @param {string} branchName - Branch that should be used for the submodule
+   */
+  submoduleSetBranch(name: string, branchName: string): void
   /**
    * Lookup a tag object by prefix hash from the repository.
    *
@@ -5565,6 +5739,325 @@ export declare class StatusesIter extends Iterator<StatusEntry, void, void> {
   next(value?: void): IteratorResult<StatusEntry, void>
 }
 
+export declare class Submodule {
+  /**
+   * Get the name for the submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   name(): string;
+   * }
+   * ```
+   */
+  name(): string
+  /**
+   *  Get the submodule's branch.
+   * ule/Methods
+   *  @signature
+   *  ```ts
+   *  class Submodule {
+   *    branch(): string | null;
+   *  }
+   *  ```
+   *  @returns The branch name of the submodule. Returns `null` if the branch if the branch is
+   *  not yet available.
+   */
+  branch(): string | null
+  /**
+   * Get the submodule's URL.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   url(): string | null;
+   * }
+   * ```
+   *
+   * @returns The URL of the submodule. Returns `null` if the URL isn't present.
+   */
+  url(): string | null
+  /**
+   * Get the path for the submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   path(): string;
+   * }
+   * ```
+   *
+   * @returns The path for the submodule.
+   */
+  path(): string
+  /**
+   * Get the OID for the submodule in the current `HEAD` tree.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   headId(): string | null;
+   * }
+   * ```
+   *
+   * @returns The OID for the submodule in the current `HEAD` tree.
+   */
+  headId(): string | null
+  /**
+   * Get the OID for the submodule in the index.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   indexId(): string | null;
+   * }
+   * ```
+   *
+   * @returns The OID for the submodule in the index.
+   */
+  indexId(): string | null
+  /**
+   * Get the OID for the submodule in the current working directory.
+   *
+   * This returns the OID that corresponds to looking up `HEAD` in the
+   * checked out submodule. If there are pending changes in the index or
+   * anything else, this won't notice that.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   workdirId(): string | null;
+   * }
+   * ```
+   *
+   * @returns The OID for the submodule in the current working directory.
+   */
+  workdirId(): string | null
+  /**
+   * Get the ignore rule that will be used for the submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   ignoreRule(): SubmoduleIgnore;
+   * }
+   * ```
+   *
+   * @returns The ignore rule that will be used for the submodule.
+   */
+  ignoreRule(): SubmoduleIgnore
+  /**
+   * Get the update rule that will be used for the submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   updateStrategy(): SubmoduleUpdate;
+   * }
+   * ```
+   *
+   * @returns The update rule that will be used for the submodule.
+   */
+  updateStrategy(): SubmoduleUpdate
+  /**
+   * Copy submodule info into ".git/config" file.
+   *
+   * Just like "git submodule init", this copies information about the
+   * submodule into ".git/config". You can use the accessor functions above
+   * to alter the in-memory git_submodule object and control what is written
+   * to the config, overriding what is in .gitmodules.
+   *
+   * By default, existing entries will not be overwritten, but passing `true`
+   * for `overwrite` forces them to be updated.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   init(
+   *     overwrite?: boolean | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<void>;
+   * }
+   * ```
+   *
+   * @param {boolean} [overwrite] - By default, existing entries will not be overwritten, but
+   * setting this to true forces them to be updated.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   */
+  init(overwrite?: boolean | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
+  /**
+   * Set up the subrepository for a submodule in preparation for clone.
+   *
+   * This function can be called to init and set up a submodule repository
+   * from a submodule in preparation to clone it from its remote.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   repoInit(
+   *     useGitlink?: boolean | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<Repository>;
+   * }
+   * ```
+   *
+   * @param {boolean} [useGitlink] - Should the workdir contain a gitlink to the repo in
+   * `.git/modules` vs. repo directly in workdir.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   *
+   * @returns The repository.
+   */
+  repoInit(useGitlink?: boolean | undefined | null, signal?: AbortSignal | undefined | null): Promise<Repository>
+  /**
+   * Open the repository for a submodule.
+   *
+   * This will only work if the submodule is checked out into the working
+   * directory.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   open(signal?: AbortSignal | null | undefined): Promise<Repository>;
+   * }
+   * ```
+   *
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   * @returns The repository.
+   */
+  open(signal?: AbortSignal | undefined | null): Promise<Repository>
+  /**
+   * Reread submodule info from config, index, and `HEAD`.
+   *
+   * Call this to reread cached submodule information for this submodule if
+   * you have reason to believe that it has changed.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   reload(
+   *     force?: boolean | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<void>;
+   * }
+   * ```
+   *
+   * @param {boolean} [force] - If this is `true`, then data will be reloaded even if it
+   * doesn't seem out of date.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   */
+  reload(force?: boolean | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
+  /**
+   * Copy submodule remote info into submodule repo.
+   *
+   * This copies the information about the submodules URL into the checked
+   * out submodule config, acting like "git submodule sync". This is useful
+   * if you have altered the URL for the submodule (or it has been altered
+   * by a fetch of upstream changes) and you need to update your local repo.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   sync(signal?: AbortSignal | null | undefined): Promise<void>;
+   * }
+   * ```
+   *
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   */
+  sync(signal?: AbortSignal | undefined | null): Promise<void>
+  /**
+   * Add current submodule HEAD commit to index of superproject.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   addToIndex(writeIndex?: boolean | null | undefined): void;
+   * }
+   * ```
+   *
+   * @param {boolean} [writeIndex] - If is true, then the index file will be immediately written.
+   * Otherwise, you must explicitly call `write()` on an `Index` later on.
+   */
+  addToIndex(writeIndex?: boolean | undefined | null): void
+  /**
+   * Resolve the setup of a new git submodule.
+   *
+   * This should be called on a submodule once you have called add setup and
+   * done the clone of the submodule. This adds the `.gitmodules` file and the
+   * newly cloned submodule to the index to be ready to be committed (but
+   * doesn't actually do the commit).
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   addFinalize(): void;
+   * }
+   * ```
+   */
+  addFinalize(): void
+  /**
+   * Update submodule.
+   *
+   * This will clone a missing submodule and check out the subrepository to
+   * the commit specified in the index of the containing repository. If
+   * the submodule repository doesn't contain the target commit, then the
+   * submodule is fetched using the fetch options supplied in options.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   update(
+   *     init?: boolean | null | undefined,
+   *     options?: SubmoduleUpdateOptions | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<void>;
+   * }
+   * ```
+   *
+   * @param {boolean} [init] - Indicates if the submodule should be initialized first if it has
+   * not been initialized yet.
+   * @param {SubmoduleUpdateOptions} [options] - Configuration options for the update.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   */
+  update(init?: boolean | undefined | null, options?: SubmoduleUpdateOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
+  /**
+   * Perform the clone step for a newly created submodule.
+   *
+   * This performs the necessary `git clone` to setup a newly-created submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   clone(
+   *     options?: SubmoduleUpdateOptions | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<Repository>;
+   * }
+   * ```
+   *
+   * @param {SubmoduleUpdateOptions} [options] - The options to use.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   * @returns The newly created repository object.
+   */
+  clone(options?: SubmoduleUpdateOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<Repository>
+}
+
 /**
  * A class to represent a git [tag][1].
  *
@@ -8304,6 +8797,145 @@ export type StatusShow =  'Index'|
 'Workdir'|
 'IndexAndWorkdir';
 
+/**
+ * Submodule ignore values
+ *
+ * These values represent settings for the `submodule.$name.ignore`
+ * configuration value which says how deeply to look at the working
+ * directory when getting the submodule status.
+ */
+export type SubmoduleIgnore = /** Use the submodule's configuration */
+'Unspecified'|
+/** Any change or untracked file is considered dirty */
+'None'|
+/** Only dirty if tracked files have changed */
+'Untracked'|
+/** Only dirty if HEAD has moved */
+'Dirty'|
+/** Never dirty */
+'All';
+
+/**
+ * Return codes for submodule status.
+ *
+ * A combination of these flags will be returned to describe the status of a
+ * submodule.  Depending on the "ignore" property of the submodule, some of
+ * the flags may never be returned because they indicate changes that are
+ * supposed to be ignored.
+ *
+ * Submodule info is contained in 4 places: the HEAD tree, the index, config
+ * files (both .git/config and .gitmodules), and the working directory.  Any
+ * or all of those places might be missing information about the submodule
+ * depending on what state the repo is in.  We consider all four places to
+ * build the combination of status flags.
+ *
+ * There are four values that are not really status, but give basic info
+ * about what sources of submodule data are available.  These will be
+ * returned even if ignore is set to "ALL".
+ *
+ * * IN_HEAD   - superproject head contains submodule
+ * * IN_INDEX  - superproject index contains submodule
+ * * IN_CONFIG - superproject gitmodules has submodule
+ * * IN_WD     - superproject workdir has submodule
+ *
+ * The following values will be returned so long as ignore is not "ALL".
+ *
+ * * INDEX_ADDED       - in index, not in head
+ * * INDEX_DELETED     - in head, not in index
+ * * INDEX_MODIFIED    - index and head don't match
+ * * WD_UNINITIALIZED  - workdir contains empty directory
+ * * WD_ADDED          - in workdir, not index
+ * * WD_DELETED        - in index, not workdir
+ * * WD_MODIFIED       - index and workdir head don't match
+ *
+ * The following can only be returned if ignore is "NONE" or "UNTRACKED".
+ *
+ * * WD_INDEX_MODIFIED - submodule workdir index is dirty
+ * * WD_WD_MODIFIED    - submodule workdir has modified files
+ *
+ * Lastly, the following will only be returned for ignore "NONE".
+ *
+ * * WD_UNTRACKED      - workdir contains untracked files
+ */
+export declare enum SubmoduleStatus {
+  InHead = 1,
+  InIndex = 2,
+  InConfig = 4,
+  InWD = 8,
+  IndexAdded = 16,
+  IndexDeleted = 32,
+  IndexModified = 64,
+  WDUninitialized = 128,
+  WDAdded = 256,
+  WDDeleted = 512,
+  WDModified = 1024,
+  WDIndexModified = 2048,
+  WDWDModified = 4096,
+  WDUntracked = 8192
+}
+
+/**
+ * Check submodule status contains given value.
+ *
+ * @category Submodule
+ * @signature
+ * ```ts
+ * function submoduleStatusContains(source: number, target: number): boolean;
+ * ```
+ *
+ * @param {number} source - Source status.
+ * @param {number} target - Target status.
+ * @returns Returns `true` is source status contains target status.
+ */
+export declare function submoduleStatusContains(source: number, target: number): boolean
+
+/**
+ * Submodule update values
+ *
+ * These values represent settings for the `submodule.$name.update`
+ * configuration value which says how to handle `git submodule update`
+ * for this submodule. The value is usually set in the ".gitmodules"
+ * file and copied to ".git/config" when the submodule is initialized.
+ */
+export type SubmoduleUpdate = /**
+ * The default; when a submodule is updated| checkout the new detached
+ * HEAD to the submodule directory.
+ */
+'Checkout'|
+/**
+ * Update by rebasing the current checked out branch onto the commit from
+ * the superproject.
+ */
+'Rebase'|
+/**
+ * Update by merging the commit in the superproject into the current
+ * checkout out branch of the submodule.
+ */
+'Merge'|
+/**
+ * Do not update this submodule even when the commit in the superproject
+ * is updated.
+ */
+'None'|
+/**
+ * Not used except as static initializer when we don't want any particular
+ * update rule to be specified.
+ */
+'Default';
+
+/** Options to update a submodule. */
+export interface SubmoduleUpdateOptions {
+  /** These options are passed to the checkout step. */
+  checkout?: CheckoutOptions
+  /** Options which control the fetch, including callbacks. */
+  fetch?: FetchOptions
+  /**
+   * Allow fetching from the submodule's default remote if the target commit isn't found.
+   * Default: `true`.
+   */
+  allowFetch?: boolean
+}
+
 /**
  * Clear the global subscriber
  *

package/index.js

@@ -608,6 +608,7 @@ module.exports.StashListIter = nativeBinding.StashListIter
 module.exports.StatusEntry = nativeBinding.StatusEntry
 module.exports.Statuses = nativeBinding.Statuses
 module.exports.StatusesIter = nativeBinding.StatusesIter
+module.exports.Submodule = nativeBinding.Submodule
 module.exports.Tag = nativeBinding.Tag
 module.exports.Tree = nativeBinding.Tree
 module.exports.TreeEntry = nativeBinding.TreeEntry
@@ -659,6 +660,10 @@ module.exports.RevparseMode = nativeBinding.RevparseMode
 module.exports.revparseModeContains = nativeBinding.revparseModeContains
 module.exports.RevwalkSort = nativeBinding.RevwalkSort
 module.exports.StatusShow = nativeBinding.StatusShow
+module.exports.SubmoduleIgnore = nativeBinding.SubmoduleIgnore
+module.exports.SubmoduleStatus = nativeBinding.SubmoduleStatus
+module.exports.submoduleStatusContains = nativeBinding.submoduleStatusContains
+module.exports.SubmoduleUpdate = nativeBinding.SubmoduleUpdate
 module.exports.traceClear = nativeBinding.traceClear
 module.exports.TraceLevel = nativeBinding.TraceLevel
 module.exports.traceSet = nativeBinding.traceSet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-git",
-  "version": "0.5.0-next.171+f871f1e",
+  "version": "0.5.0-next.172+1b12e25",
   "main": "index.js",
   "types": "index.d.ts",
   "files": [
@@ -54,15 +54,15 @@
     "vitest": "^3.0.5"
   },
   "optionalDependencies": {
-    "es-git-darwin-x64": "0.5.0-next.171+f871f1e",
-    "es-git-darwin-arm64": "0.5.0-next.171+f871f1e",
-    "es-git-win32-x64-msvc": "0.5.0-next.171+f871f1e",
-    "es-git-win32-arm64-msvc": "0.5.0-next.171+f871f1e",
-    "es-git-linux-x64-gnu": "0.5.0-next.171+f871f1e",
-    "es-git-linux-x64-musl": "0.5.0-next.171+f871f1e",
-    "es-git-android-arm64": "0.5.0-next.171+f871f1e",
-    "es-git-linux-arm64-gnu": "0.5.0-next.171+f871f1e",
-    "es-git-linux-arm64-musl": "0.5.0-next.171+f871f1e",
-    "es-git-android-arm-eabi": "0.5.0-next.171+f871f1e"
+    "es-git-darwin-x64": "0.5.0-next.172+1b12e25",
+    "es-git-darwin-arm64": "0.5.0-next.172+1b12e25",
+    "es-git-win32-x64-msvc": "0.5.0-next.172+1b12e25",
+    "es-git-win32-arm64-msvc": "0.5.0-next.172+1b12e25",
+    "es-git-linux-x64-gnu": "0.5.0-next.172+1b12e25",
+    "es-git-linux-x64-musl": "0.5.0-next.172+1b12e25",
+    "es-git-android-arm64": "0.5.0-next.172+1b12e25",
+    "es-git-linux-arm64-gnu": "0.5.0-next.172+1b12e25",
+    "es-git-linux-arm64-musl": "0.5.0-next.172+1b12e25",
+    "es-git-android-arm-eabi": "0.5.0-next.172+1b12e25"
   }
 }