索引付きデータベース API — Indexed Database API 3.0

`Range@ ( %値, %~NULL不可 （省略時は ε ） ) は、 次を走らす： ◎ To convert a value to a key range with value and optional null disallowed flag, run these steps:

1. %値 に応じて：

   `~key範囲$である

   ~RET %値 ◎ If value is a key range, return value.

   ε

   ~NULL†

   1. ~IF ［ %~NULL不可 ~NEQ ε ］ ⇒ ~THROW `DataError$E
   2. ~RET `全範囲$

   ◎ If value is undefined or is null, then throw a "DataError" DOMException if null disallowed flag is true, or return an unbounded key range otherwise.

   その他

   ~RET `Only$( `Key$( %値 ) ) ？ ◎ Let key be the result of converting a value to a key with value. Rethrow any exceptions. ◎ If key is invalid, throw a "DataError" DOMException. ◎ Return a key range containing only key.

【† この手続きは、 ~key範囲を期待する引数 （この仕様では，名前 %query の引数として記される） をとる~API~methodから呼び出される。 その引数が省略可能であって, ~NULL が渡された場合、 特別に，引数が省略されたとき（ ε ）と同じに扱われることになる。 】

`保管庫~用の~keyを生成する@ ~algoは、 所与の ( `保管庫$ %保管庫 ) に対し： ◎ To generate a key for an object store store, run these steps:

1. %生成器 ~LET %保管庫 の`~key生成器$ ◎ Let generator be store’s key generator.
2. %~key ~LET %生成器 の`現在の番号$ ◎ Let key be generator’s current number.
3. ~IF［ %~key ~GT `最大な番号$ ］ ⇒ ~RET `失敗^i ◎ If key is greater than 253 (9007199254740992), then return failure.
4. %生成器 の`現在の番号$ ~INCBY 1 ◎ Increase generator’s current number by 1.
5. ~RET %~key ◎ Return key.

`保管庫~用の~key生成器を可能なら更新する@ ~algoは、 所与の ( `保管庫$ %保管庫, `~key$ %~key ) に対し： ◎ To possibly update the key generator for an object store store with key, run these steps:

1. ~IF［ %~key の`型$key ~NEQ `number$i ］ ⇒ ~RET ◎ If the type of key is not number, abort these steps.
2. %値 ~LET 次を満たす最大な整数 ⇒ ［ %値 ~LTE %~key の`値$key ］~AND［ %値 ~LTE `最大な番号$ ］ ◎ Let value be the value of key. ◎ Set value to the minimum of value and 253 (9007199254740992). ◎ Set value to the largest integer not greater than value.
3. %生成器 ~LET %保管庫 の`~key生成器$ ◎ Let generator be store’s key generator.
4. ~IF［ %値 ~GTE %生成器 の`現在の番号$ ］ ⇒ %生成器 の`現在の番号$ ~SET %値 + 1 ◎ If value is greater than or equal to generator’s current number, then set generator’s current number to value + 1.

`result@m 取得子~手続きは： ◎ The result getter steps are:

1. ~IF［ コレの`済んだか$ ~EQ ~F ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s done flag is false, then throw an "InvalidStateError" DOMException.
2. ~RET ［ コレの`結果$ ~NEQ ε ならば それ ／ ~ELSE_（すなわちコレの`~error$ ~NEQ ε ） `undefined^jv ］ ◎ Return this’s result, or undefined if the request resulted in an error.

【 結果 ~NEQ ε の場合でも，結果~自身は `undefined^jv にもなり得る （ `IDBObjectStore.get()$m の注記を見よ）。 】

`error@m 取得子~手続きは： ◎ The error getter steps are:

1. ~IF［ コレの`済んだか$ ~EQ ~F ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s done flag is false, then throw an "InvalidStateError" DOMException.
2. ~RET［ コレの`~error$ ~NEQ ε ならば それ ／ ~ELSE_（すなわちコレの`結果$ ~NEQ ε ならば） ~NULL ］ ◎ Return this’s error, or null if no error occurred.

`transaction@m 取得子~手続きは ⇒ ~RET ［ コレの`設置-先~tx$ ~NEQ ε ならば それ ／ ~ELSE_ ~NULL ］ ◎ The transaction getter steps are to return this’s transaction.

注記： この取得子は、 ある種の要請 — `IDBFactory.open()$m から返される`要請$など — においては ~NULL を返すこともある。 ◎ NOTE: The transaction getter can return null for certain requests, such as for requests returned from open().

`~version変更~eventを発火する@ ~algoは、 所与の ( %~target, %~event名, %旧~version, %新~version ) に対し： ◎ To fire a version change event named e at target given oldVersion and newVersion, run these steps:

1. %~event ~LET `~eventを作成する$( `IDBVersionChangeEvent$I ) ◎ Let event be the result of creating an event using IDBVersionChangeEvent.
2. %~event の各種~属性を次のように初期化する ⇒＃ `type$m ~SET %~event名, `bubbles$m ~SET ~F, `cancelable$m ~SET ~F, `oldVersion$m ~SET %旧~version, `newVersion$m ~SET %新~version ◎ • Set event’s type attribute to e. • Set event’s bubbles and cancelable attributes to false. • Set event’s oldVersion attribute to oldVersion. • Set event’s newVersion attribute to newVersion.
3. ~RET `Dispatch$( %~target, %~event ) ◎ Let legacyOutputDidListenersThrowFlag be false. ◎ Dispatch event at target with legacyOutputDidListenersThrowFlag. ◎ Return legacyOutputDidListenersThrowFlag.

注記： この~algoの結果は利用されないこともある。 ◎ NOTE: The return value of this algorithm is not always used.

`open(name, version)@m ~method手続きは： ◎ The open(name, version) method steps are:

1. ~IF［ %version ~EQ 0 ］ ⇒ ~THROW `TypeError$E ◎ If version is 0 (zero), throw a TypeError.
2. %~storage~key ~LET `~storage~keyを得する$( コレに`関連な設定群~obj$ ) ◎ Let environment be this’s relevant settings object. ◎ Let storageKey be the result of running obtain a storage key given environment.＼
3. ~IF［ %~storage~key ~EQ `失敗^i ］ ⇒ ~THROW `SecurityError$E ◎ If failure is returned, then throw a "SecurityError" DOMException and abort these steps.
4. %要請 ~LET 新たな`~open要請$ ◎ Let request be a new open request.

5. この段は、 `並列的$に走らす： ◎ Run these steps in parallel:

   1. %結果 ~LET `~db接続を~openする$( %~storage~key, %name, %version, %要請 ) ◎ Let result be the result of opening a database connection, with storageKey, name, version if given and undefined otherwise, and request.

      注記： 名前 %name の`~db$が存在しなければ、 新たな`~db$が作成される。 %version が与えられていない場合、 接続は，［ 既存の~dbに対しては その`~version$dbを変更することなく ／ 新たな~dbに対しては その`~version$dbを 1 にして ］~openすることになる。 【！ details 】 ◎ What happens if version is not given? ◎ If version is not given and a database with that name already exists, a connection will be opened without changing the version. If version is not given and no database with that name exists, a new database will be created with version equal to 1.

   2. %要請 の`処理-済みか$ ~SET ~T ◎ Set request’s processed flag to true.

   3. 次を走らす`~taskを~queueする$： ◎ Queue a task to run these steps:

      1. %要請 の ⇒＃ `済んだか$ ~SET ~T, `結果$ ~SET ε, `~error$ ~SET ε ◎ ↓

      2. ~IF［ %結果 は~errorである ］：

         1. %要請 の`~error$ ~SET %結果
         2. `~eventを発火する$( %要請, `error$et ) — 次のように初期化して ⇒＃ `bubbles$m 属性 ~SET ~T, `cancelable$m 属性 ~SET ~T
         ◎ If result is an error, then: • Set request’s result to undefined. • Set request’s error to result. • Set request’s done flag to true. • Fire an event named error at request with its bubbles and cancelable attributes initialized to true.

      3. ~ELSE：

         1. %要請 の`結果$ ~SET %結果
         2. `~eventを発火する$( %要請, `success$et )

         ◎ Otherwise: • Set request’s result to result. • Set request’s done flag to true. • Fire an event named success at request.

         注記： 上の【`~db接続を~openする$】手続きが`昇格~tx$を稼働させた場合、 この段は，それが`完遂-$した後に走ることになる。 これは、 別の~versionへの昇格が起こりつつある場合に，最初に`接続$上に `success$et ~eventを発火して、 ~scriptが［ `versionchange$et ~event用の~listenerを登録する機会c ］を得られることを確保する【？】。 ◎ NOTE: If the steps above resulted in an upgrade transaction being run, these steps will run after that transaction finishes. This ensures that in the case where another version upgrade is about to happen, the success event is fired on the connection first so that the script gets a chance to register a listener for the versionchange event.

         注記： ここで，通常の［ `~success~eventを発火する$ ／ `~error~eventを発火する$ ］手続きを適用しないのは、 要請の`設置-先~tx$がないためである （その手続きは，`設置-先~tx$を配送-前に作動化して配送-後に作動中でなくする）。 【！ details 】 ◎ Why aren’t the steps to fire a success event or fire an error event used? ◎ There is no transaction associated with the request (at this point), so those steps — which activate an associated transaction before dispatch and deactivate the transaction after dispatch — do not apply.

6. ~RET %要請 を表現する，新たな `IDBOpenDBRequest$I ~obj ◎ Return a new IDBOpenDBRequest object for request.

`deleteDatabase(name)@m ~method手続きは： ◎ The deleteDatabase(name) method steps are:

1. %~storage~key ~LET `~storage~keyを得する$( コレに`関連な設定群~obj$ ) ◎ Let environment be this’s relevant settings object. ◎ Let storageKey be the result of running obtain a storage key given environment.＼
2. ~IF［ %~storage~key ~EQ `失敗^i ］ ⇒ ~THROW `SecurityError$E ◎ If failure is returned, then throw a "SecurityError" DOMException and abort these steps.
3. %要請 ~LET 新たな`~open要請$ ◎ Let request be a new open request.

4. この段は、 `並列的$に走らす： ◎ Run these steps in parallel:

   1. %結果 ~LET `~dbを削除する$( %~storage~key, %name, %要請 ) ◎ Let result be the result of deleting a database, with storageKey, name, and request.
   2. %要請 の`処理-済みか$ ~SET ~T ◎ Set request’s processed flag to true.

   3. 次を走らす`~taskを~queueする$： ◎ Queue a task to run these steps:

      1. %要請 の ⇒＃ `済んだか$ ~SET ~T, `結果$ ~SET ε, `~error$ ~SET ε ◎ ↓

      2. ~IF［ %結果 は~errorである ］：

         1. %要請 の`~error$ ~SET %結果
         2. `~eventを発火する$( %要請, `error$et ) — 次のように初期化して ⇒＃ `bubbles$m 属性 ~SET ~T, `cancelable$m 属性 ~SET ~T
         ◎ If result is an error, set request’s error to result, set request’s done flag to true, and fire an event named error at request with its bubbles and cancelable attributes initialized to true.

      3. ~ELSE：

         1. %要請 の`結果$ ~SET ε
         2. `~version変更~eventを発火する$( %要請, `success$et, %結果, ~NULL )
         ◎ Otherwise, set request’s result to undefined, set request’s done flag to true, and fire a version change event named success at request with result and null.

      注記： この時点では、 要請の`設置-先~tx$はないので、 通常の［ `~success~eventを発火する$ ／ `~error~eventを発火する$ ］手続きは （それは，`設置-先~tx$を配送-前に作動化して配送-後に作動中でなくする）， 適用できない。 また、 ここでの `success$et ~eventは `IDBVersionChangeEvent$I であり， `oldVersion^m, `newVersion^m も含んでいる。 【！ details 】 ◎ Why aren’t the steps to fire a success event or fire an error event used? ◎ There is no transaction associated with the request, so those steps — which activate an associated transaction before dispatch and deactivate the transaction after dispatch — do not apply. ◎ Also, the success event here is a IDBVersionChangeEvent which includes the oldVersion and newVersion details.

5. ~RET %要請 を表現する，新たな `IDBOpenDBRequest$I ~obj ◎ Return a new IDBOpenDBRequest object for request.

`databases()@m ~method手続きは： ◎ The databases() method steps are:

1. %~storage~key ~LET `~storage~keyを得する$( コレに`関連な設定群~obj$ ) ◎ Let environment be this’s relevant settings object. ◎ Let storageKey be the result of running obtain a storage key given environment.＼
2. ~IF［ %~storage~key ~EQ `失敗^i ］ ⇒ ~RET `却下される~promise$( `SecurityError$E 例外 ) ◎ If failure is returned, then return a promise rejected with a "SecurityError" DOMException
3. %p ~LET `新たな~promise$ ◎ Let p be a new promise.

4. この段は、 `並列的$に走らす： ◎ Run these steps in parallel:

   1. %~db群 ~LET %~storage~key に`専属する$`~db$たちからなる`集合$ ⇒ ~IF［ 何らかの理由でこれを決定できない ］ ⇒＃ `~promiseを却下する$( %p, 適切な~error（例： `UnknownError$E 例外）)； ~RET ◎ Let databases be the set of databases in storageKey. If this cannot be determined for any reason, then reject p with an appropriate error (e.g. an "UnknownError" DOMException) and terminate these steps.
   2. %~db~list ~LET 新たな`~list$ ◎ Let result be a new list.

   3. %~db群 を成す ~EACH( `~db$ %~db ) に対し： ◎ For each db of databases:

      1. %info ~LET 新たな `IDBDatabaseInfo$I 辞書 ◎ Let info be a new IDBDatabaseInfo dictionary.
      2. %info[ "`name^m" ] ~SET %~db の`名前$db, ◎ Set info’s name dictionary member to db’s name.
      3. %info[ "`version^m" ] ~SET %~db の `~version$db ◎ Set info’s version dictionary member to db’s version.
      4. %~db~list に %info を`付加する$ ◎ Append info to result.

      【 %~db群 の順序は定義されていないので、 結果の順序も定義されないことになる。 】

   4. `~promiseを解決する$( %p, %~db~list ) ◎ Resolve p with result.
5. ~RET %p ◎ Return p.

🚧 これは、 この版による新たな~methodである。 ［ Chrome 71, Edge 79, Firefox 126, Safari 14 ］から~supportされている。 🚧 ◎ 🚧 The databases() method is new in this edition. It is supported in Chrome 71, Edge 79, Firefox 126, and Safari 14. 🚧

`cmp(first, second)@m ~method手続きは： ◎ The cmp(first, second) method steps are:

1. %a ~LET `Key$( %first ) ？ ◎ Let a be the result of converting a value to a key with first. Rethrow any exceptions. ◎ If a is invalid, throw a "DataError" DOMException.
2. %b ~LET `Key$( %second ) ？ ◎ Let b be the result of converting a value to a key with second. Rethrow any exceptions. ◎ If b is invalid, throw a "DataError" DOMException.
3. ~RET `Compare$( %a, %b ) ◎ Return the results of comparing two keys with a and b.

`name@m 取得子~手続きは ⇒ ~RET コレ↗の`名前$db ◎ The name getter steps are to return this’s associated database’s name.

注記： この属性は、 `値を保ち続ける$。 ◎ NOTE: The name attribute returns this name even if this’s close pending flag is true. In other words, the value of this attribute stays constant for the lifetime of the IDBDatabase instance.

`version@m 取得子~手続きは ⇒ ~RET コレの`~version$Cn ◎ The version getter steps are to return this’s version.

注記： この属性は、 コレの`状態$Cn ~EQ `~open中$i の間は，コレ↗の`~version$dbと同じ値を返し、 それ以降も同じ`値を保ち続ける$。 【！ details 】 ◎ Is this the same as the database’s version? ◎ As long as the connection is open, this is the same as the connected database’s version. But once the connection has closed, this attribute will not reflect changes made with a later upgrade transaction.

`objectStoreNames@m 取得子~手続きは： ◎ The objectStoreNames getter steps are:

1. %名前~群 ~LET ［ コレの`保管庫~集合$Cnを成す各`保管庫$の`名前$Os ］たちが成す`~list$ ◎ Let names be a list of the names of the object stores in this’s object store set.
2. ~RET `~sort済み名前~listを作成する$( %名前~群 ) ◎ Return the result (a DOMStringList) of creating a sorted name list with names.

注記： この属性は、［ コレの`状態$Cn ~EQ `~open中$i ］の間は，コレ↗に専属する各`保管庫$の`名前$Osたちが成す~listと同じ値を返し、 それ以降も同じ`値を保ち続ける$。 ◎ Is this the same as the database’s object store names? ◎ As long as the connection is open, this is the same as the connected database’s object store names. But once the connection has closed, this attribute will not reflect changes made with a later upgrade transaction.

`createObjectStore(name, options)@m ~method手続きは： ◎ The createObjectStore(name, options) method steps are:

1. %~tx ~LET コレ↗の`昇格~tx$db ◎ Let database be this’s associated database. ◎ Let transaction be database’s upgrade transaction if it is not null,＼

2. ~IF［ %~tx ~EQ ε ］ ⇒ ~THROW `InvalidStateError$E

   【 %~tx がコレ↗に`専属しない$場合も例外を投出するべきでは？ 】

   ◎ or throw an "InvalidStateError" DOMException otherwise.
3. ~IF［ %~tx の`状態$tx ~NEQ `作動中$i ］ ⇒ ~THROW `TransactionInactiveError$E ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
4. %keyPath ~LET %options[ "`keyPath$mb" ] ◎ Let keyPath be options’s keyPath member if it is not undefined or null, or null otherwise.
5. ~IF［ %keyPath ~NEQ ~NULL ］~AND［ %keyPath は`妥当な~key~path$でない ］ ⇒ ~THROW `SyntaxError$E ◎ If keyPath is not null and is not a valid key path, throw a "SyntaxError" DOMException.
6. ~IF［ コレの`保管庫~集合$Cn内に［ `名前$Os ~EQ %name ］なる`保管庫$がある ］ ⇒ ~THROW `ConstraintError$E ◎ If an object store named name already exists in database throw a "ConstraintError" DOMException.
7. %自動生成か ~LET %options[ "`autoIncrement$mb" ] ◎ Let autoIncrement be options’s autoIncrement member.
8. ~IF［ %自動生成か ~EQ ~T ］ ⇒ ~IF［ %keyPath ~EQ 空な `DOMString$I 値である ］~OR［ %keyPath は `~SeqDS$ 型である ］ ⇒ ~THROW `InvalidAccessError$E ◎ If autoIncrement is true and keyPath is an empty string or any sequence (empty or otherwise), throw an "InvalidAccessError" DOMException.
9. %保管庫 ~LET 次のようにされた，新たな`保管庫$ — その ⇒＃ コレ↗に`専属する$, `~record~list$Os ~SET 空~list, `名前$Os ~SET %name, `~key生成器$を［ %自動生成か ~EQ ~T ならば有する ／ ~ELSE_ 有さない ］, `~key~path$Os ~SET ［ %keyPath ~NEQ ~NULL ならば %keyPath ／ ~ELSE_ ε ］ ◎ Let store be a new object store in database. Set the created object store’s name to name. If autoIncrement is true, then the created object store uses a key generator. If keyPath is not null, set the created object store’s key path to keyPath.
10. コレの`保管庫~集合$Cnに %保管庫 を追加する 【この段は、この訳による補完】
11. ~RET 次のようにされた，新たな`保管庫~handle$ %H ⇒＃ %H↗ ~EQ %保管庫, %H は %~tx に`専属する$ ◎ Return a new object store handle associated with store and transaction.

この~methodは、 新たな`保管庫$を作成した上で，それを`~access先$とする新たな`保管庫~handle$を返す。 この~methodを~callできるのは、 `昇格~txの中$からに限られることに注意。 ◎ This method creates and returns a new object store with the given name in the connected database. Note that this method must only be called from within an upgrade transaction.

この~methodは，コレ上の `objectStoreNames$m 属性を同期的に改変する。 ◎ This method synchronously modifies the objectStoreNames property on the IDBDatabase instance on which it was called.

`deleteObjectStore(name)@m ~method手続きは： ◎ The deleteObjectStore(name) method steps are:

1. %~tx ~LET コレ↗の`昇格~tx$db ◎ Let database be this’s associated database. ◎ Let transaction be database’s upgrade transaction if it is not null,＼

2. ~IF［ %~tx ~EQ ε ］ ⇒ ~THROW `InvalidStateError$E

   【 %~tx がコレ↗に`専属しない$場合も例外を投出するべきでは？ 】

   ◎ or throw an "InvalidStateError" DOMException otherwise.
3. ~IF［ %~tx の`状態$tx ~NEQ `作動中$i ］ ⇒ ~THROW `TransactionInactiveError$E ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
4. %保管庫 ~LET コレの`保管庫~集合$Cn内の［ `名前$Os ~EQ %name ］なる`保管庫$ ◎ Let store be the object store named name in database,＼
5. ~IF［ %保管庫 ~EQ ε ］ ⇒ ~THROW `NotFoundError$E ◎ or throw a "NotFoundError" DOMException if none.
6. コレの`保管庫~集合$Cnから %保管庫 を除去する ◎ Remove store from this’s object store set.
7. ~IF［ %~tx に`専属する$, かつ %保管庫 を`~access先$とする`保管庫~handle$ %H がある ］ ⇒ %H の`索引~集合$OsHを空にする ◎ If there is an object store handle associated with store and transaction, remove all entries from its index set.
8. コレ↗内の %保管庫 を（ %保管庫 に`専属する$`索引$たちも込みで）破壊する ◎ Destroy store.

この~methodは、 この`接続$↗に専属している，名前 %name の`保管庫$を破壊する。 この~methodを~callできるのは、 `昇格~txの中$からに限られることに注意。 ◎ This method destroys the object store with the given name in the connected database. Note that this method must only be called from within an upgrade transaction.

この~methodは，コレ上の `objectStoreNames$m 属性を同期的に改変する。 ◎ This method synchronously modifies the objectStoreNames property on the IDBDatabase instance on which it was called.

`transaction(storeNames, mode, options)@m ~method手続きは： ◎ The transaction(storeNames, mode, options) method steps are:

1. ~IF［ コレ↗の`昇格~tx$db ~NEQ ε ］~AND［ コレ↗の`昇格~tx$dbは`生きて$いる ］ ⇒ ~THROW `InvalidStateError$E ◎ If a live upgrade transaction is associated with the connection, throw an "InvalidStateError" DOMException.
2. ~IF［ コレの`状態$Cn ~NEQ `~open中$i ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s close pending flag is true, then throw an "InvalidStateError" DOMException.
3. %視野 ~LET %storeNames の型に応じて ⇒＃ `~SeqDS$ ならば，その中の一意な文字列たちが成す集合（集合なので，重複するものは一つにする）／ `DOMString$I ならば，その文字列のみからなる集合 ◎ Let scope be the set of unique strings in storeNames if it is a sequence, or a set containing one string equal to storeNames otherwise.
4. ~IF［ %視野 内に，コレの`保管庫~集合$Cn内のどの`保管庫$の`名前$Osにも一致しないものがある ］ ⇒ ~THROW `NotFoundError$E ◎ If any string in scope is not the name of an object store in the connected database, throw a "NotFoundError" DOMException.
5. ~IF［ %視野 は 空である ］ ⇒ ~THROW `InvalidAccessError$E ◎ If scope is empty, throw an "InvalidAccessError" DOMException.
6. ~IF［ %mode ~NIN { `readonly$l, `readwrite$l } ］ ⇒ ~THROW `TypeError$E ◎ If mode is not "readonly" or "readwrite", throw a TypeError.
7. %~tx ~LET 新たに`作成-$された`~tx$ — その ⇒＃ `視野$ ~SET ［ コレの`保管庫~集合$Cn内の， %視野 により指示される`保管庫$ ］たちが成す集合, `~mode$ ~SET %mode, `専属する$`接続$ ~SET コレ, `耐久能~hint$ ~SET %options[ "`durability$mb" ] ◎ Let transaction be a newly created transaction with this connection, mode, options’ durability member, and the set of object stores named in scope.
8. %~tx の`片付ける~event~loop$ ~SET 現在の`~event~loop$ ◎ Set transaction’s cleanup event loop to the current event loop.
9. ~RET %~tx を表現する `IDBTransaction$I ~obj ◎ Return an IDBTransaction object representing transaction.

🚧 `durability$m は、 この版による新たな~optionである。 ［ Chrome 82, Edge 82, Firefox 126, Safari 15 ］から~supportされている。 🚧 ◎ 🚧 The durability option is new in this edition. It is supported in Chrome 82, Edge 82, Firefox 126, and Safari 15. 🚧

注記： 作成された~txは、 その`存続期間$の規則に従う。 ◎ NOTE: The created transaction will follow the lifetime rules.

`close()@m ~method手続きは ⇒ `~db接続を~closeする$( コレ ) ◎ The close() method steps are: • Run close a database connection with this connection.

注記： 未決な`~tx$すべてが完了するまでは、 `接続$は実際には`~close$されない。 `close()$m に対する後続な~callには、 効果はない。 ◎ NOTE: The connection will not actually close until all outstanding transactions have completed. Subsequent calls to close() will have no effect.

`name@m 取得子~手続きは ⇒ ~RET コレの`名前$OsH ◎ The name getter steps are to return this’s name.

注記： この属性は、 コレが`専属する$~txが`完遂-$するまでは，コレ↗の`名前$Osと同じ値を返し、 それ以降も同じ`値を保ち続ける$。 【！ details 】 ◎ Is this the same as the object store’s name? ◎ As long as the transaction has not finished, this is the same as the associated object store’s name. But once the transaction has finished, this attribute will not reflect changes made with a later upgrade transaction.

`name$m 設定子~手続きは： ◎ The name setter steps are:

1. `状態を検査する$( コレ, `versionchange^l ) ？ ◎ Let name be the given value. ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ 変則＊ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction is not an upgrade transaction, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, throw a "TransactionInactiveError" DOMException.
2. %name ~LET `所与の値$ ◎ ↑
3. ~IF［ コレの`名前$OsH ~EQ %name ］ ⇒ ~RET ◎ If store’s name is equal to name, terminate these steps.
4. ~IF［ コレが`専属する$`接続$の`保管庫~集合$Cnに［ `名前$Os ~EQ %name ］なる`保管庫$がある ］ ⇒ ~THROW `ConstraintError$E ◎ If an object store named name already exists in store’s database, throw a "ConstraintError" DOMException.
5. コレ↗の`名前$Os ~SET %name ◎ Set store’s name to name.
6. コレの`名前$OsH ~SET %name ◎ Set this’s name to name.

`keyPath@m 取得子~手続きは ⇒ ~RET コレ↗の`~key~path$Os %P に応じて，［ %P ~EQ ε ならば ~NULL ／ ~ELSE_ %P を `WEBIDL$r に従って，次の型として変換した結果 ］ ⇒＃ %P は文字列であるならば `DOMString$I ／ %P は文字列たちが成す~listであるならば `~SeqDS$ ◎ The keyPath getter steps are to return this’s object store’s key path, or null if none. The key path is converted as a DOMString (if a string) or a sequence<DOMString> (if a list of strings), per [WEBIDL].

【この属性は、`値を保ち続ける$。】

注記： 返される値は、 コレの作成-時に利用した~instanceと同じではない。 しかしながら，この属性が~obj（特定的には `Array$jT ）を返す場合、 毎回~同じ~instanceを返す。 返された~objの~prop値を変更しても，コレに効果を及ぼすことはない。 ◎ NOTE: The returned value is not the same instance that was used when the object store was created. However, if this attribute returns an object (specifically an Array), it returns the same object instance every time it is inspected. Changing the properties of the object has no effect on the object store.

`indexNames@m 取得子~手続きは： ◎ The indexNames getter steps are:

1. %名前~群 ~LET ［ コレの`索引~集合$OsHを成す各`索引$の`名前$Ix ］たちが成す`~list$ ◎ Let names be a list of the names of the indexes in this’s index set.
2. ~RET `~sort済み名前~listを作成する$( %名前~群 ) ◎ Return the result (a DOMStringList) of creating a sorted name list with names.

注記： この属性は、 コレが`専属する$~txが`完遂-$するまでは，コレ↗に専属する各`索引$の名前たちが成す~listと同じ値を返し、 それ以降も同じ`値を保ち続ける$。 【！ deitails 】 ◎ Is this the same as object store’s list of index names? ◎ As long as the transaction has not finished, this is the same as the associated object store’s list of index names. But once the transaction has finished, this attribute will not reflect changes made with a later upgrade transaction.

`transaction@m 取得子~手続きは ⇒ ~RET コレが`専属する$~tx ◎ The transaction getter steps are to return this’s transaction.

`autoIncrement@m 取得子~手続きは ⇒ ~RET ~IS［ コレ↗の`~key生成器$ ~NEQ ε ］ ◎ The autoIncrement getter steps are to return true if this’s object store has a key generator, and false otherwise.

【この属性は、`値を保ち続ける$。】

`addするかputする@ ~algoは、 所与の ( %~handle, %value, %key, %上書不可か ) に対し： ◎ To add or put with handle, value, key, and no-overwrite flag, run these steps:

1. `状態を検査する$( %~handle, `readwrite^l ) ？ ◎ Let transaction be handle’s transaction. ◎ Let store be handle’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ If transaction is a read-only transaction, throw a "ReadOnlyError" DOMException.
2. %keyPath ~LET %~handle の`~key~path$Os ◎ ↓
3. %生成器 ~LET %~handle の`~key生成器$ ◎ ↓
4. ~IF［ %keyPath ~NEQ ε ］~AND［ %key ~NEQ ε ］ ⇒ ~THROW `DataError$E ◎ If store uses in-line keys and key was given, throw a "DataError" DOMException.
5. ~IF［ %keyPath ~EQ ε ］~AND［ %key ~EQ ε ］~AND［ %生成器 ~EQ ε ］ ⇒ ~THROW `DataError$E ◎ If store uses out-of-line keys and has no key generator and key was not given, throw a "DataError" DOMException.
6. ~IF［ %key ~NEQ ε ］ ⇒ %key ~LET `Key$( %key ) ？ ◎ If key was given, then: • Let r be the result of converting a value to a key with key. Rethrow any exceptions. • If r is invalid, throw a "DataError" DOMException. • Let key be r.
7. %clone ~LET `~txの間に値を~cloneする$( %value, %~handle が`専属する$`~tx$ ) ？ ◎ Let targetRealm be a user-agent defined Realm. ◎ Let clone be a clone of value in targetRealm during transaction. Rethrow any exceptions. ◎ Why create a copy of the value? ◎ The value is serialized when stored. Treating it as a copy here allows other algorithms in this specification to treat it as an ECMAScript value, but implementations can optimize this if the difference in behavior is not observable.

8. ~IF［ %keyPath ~NEQ ε ］：

   1. %抽出d~key ~LET `Extract$( %clone, %keyPath, %生成器 ) ？
   2. ~IF［ %抽出d~key ~NEQ ε ］ ⇒ %key ~SET %抽出d~key
   3. ~ELIF［ `~keyを値の中へ注入できるか検査する$( %clone, %keyPath ) の結果 ~EQ ~F ］ ⇒ ~THROW `DataError$E
   ◎ If store uses in-line keys, then: • Let kpk be the result of extracting a key from a value using a key path with clone and store’s key path. Rethrow any exceptions. • If kpk is invalid, throw a "DataError" DOMException. • If kpk is not failure, let key be kpk. • Otherwise (kpk is failure): •• If store does not have a key generator, throw a "DataError" DOMException. •• If check that a key could be injected into a value with clone and store’s key path return false, throw a "DataError" DOMException.
9. ~RET 次の`演算$を走らす`要請を非同期に実行する$( %~handle ) ⇒ `保管庫に~recordを格納する$( %~handle↗, %clone, %key, %上書不可か ) ◎ Let operation be an algorithm to run store a record into an object store with store, clone, key, and no-overwrite flag. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with handle and operation.

`delete(query)@m ~method手続きは： ◎ The delete(query) method steps are:

1. `状態を検査する$( コレ, `readwrite^l ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ If transaction is a read-only transaction, throw a "ReadOnlyError" DOMException.
2. %範囲 ~LET `Range$( %query, `~NULL不可^i ) ？ ◎ Let range be the result of converting a value to a key range with query and true. Rethrow any exceptions.
3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `保管庫から~recordを削除する$( コレ↗, %範囲 ) ◎ Let operation be an algorithm to run delete records from an object store with store and range. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$たちが削除される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the records to be deleted.

注記： 他の~methodと違って、 この~methodの %query 引数は， 省略可能でなく, ~NULL 値も許容されない （すなわち，`全範囲$は指定できない）。 これは、 小さな~bugにより，保管庫の中を全~clearする~riskを抑制するためである。 ◎ NOTE: Unlike other methods which take keys or key ranges, this method does not allow null to be given as key. This is to reduce the risk that a small bug would clear a whole object store.

`clear()@m ~method手続きは： ◎ The clear() method steps are:

1. `状態を検査する$( コレ, `readwrite^l ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ If transaction is a read-only transaction, throw a "ReadOnlyError" DOMException.
2. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `保管庫を~clearする$( コレ↗ ) ◎ Let operation be an algorithm to run clear an object store with store. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

`get(query)@m ~method手続きは： ◎ The get(query) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.

2. %範囲 ~LET `Range$( %query, `~NULL不可^i ) ？ ◎ Let range be the result of converting a value to a key range with query and true. Rethrow any exceptions.

3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る最初の~entryを検索取得する$( コレ↗, %範囲, `値^i ) ◎ Let operation be an algorithm to run retrieve a value from an object store with the current Realm record, store, and range. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$ （範囲が指定された場合、 範囲に入る最初の既存の~record） の`値$が検索取得される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the record value to be retrieved. If a range is specified, the method retrieves the first existing value in that range.

注記： この~methodによる要請の`結果$は、 所与の~keyを伴う~recordが存在しない場合も, `値$が `undefined^jv の~recordが存在する場合も， `undefined^jv 値になる。 両者を区別する必要があるときは、 同じ~keyで `openCursor()$m を利用できる — その`結果$は、 ~recordが存在しなければ ~NULL になる一方で，存在するときは［ `値$Cs ~SET `undefined^jv† ］にされた`~cursor$になる。 【† この訳では、内部処理~modelにおいては，値 ε により，そのような~recordが存在する場合とを区別している。】 ◎ NOTE: This method produces the same result if a record with the given key doesn’t exist as when a record exists, but has undefined as value. If you need to tell the two situations apart, you can use openCursor() with the same key. This will return a cursor with undefined as value if a record exists, or no cursor if no such record exists.

`getKey(query)@m ~method手続きは： ◎ The getKey(query) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query, `~NULL不可^i ) ？ ◎ Let range be the result of converting a value to a key range with query and true. Rethrow any exceptions.
3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る最初の~entryを検索取得する$( コレ↗, %範囲, `~key^i ) ◎ Let operation be an algorithm to run retrieve a key from an object store with store and range. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$ （範囲が指定された場合、 範囲に入る最初の既存の~record） の`~key$が検索取得される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the record key to be retrieved. If a range is specified, the method retrieves the first existing key in that range.

`getAll(query, count)@m ~method手続きは： ◎ The getAll(query, count) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.

2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.

3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る~entryたちを検索取得する$( コレ↗, %範囲, %count, `値^i ) ◎ Let operation be an algorithm to run retrieve multiple values from an object store with the current Realm record, store, range, and count if given. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$たちの`値$が検索取得される。 ~NULL または省略時には，`全範囲$が利用される。 %count が指定されていて，範囲に入る~record数がそれを超える場合、 最初から %count 個までが検索取得される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the record values to be retrieved. If null or not given, an unbounded key range is used. If count is specified and there are more than count records in range, only the first count will be retrieved.

`getAllKeys(query, count)@m ~method手続きは： ◎ The getAllKeys(query, count) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.

2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.

3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る~entryたちを検索取得する$( コレ↗, %範囲, %count, `~key^i ) ◎ Let operation be an algorithm to run retrieve multiple keys from an object store with store, range, and count if given. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$たちの`~key$が検索取得される。 ~NULL または省略時には，`全範囲$が利用される。 %count が指定されていて，範囲に入る~key数がそれを超える場合、 最初から %count 個までが検索取得される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the record keys to be retrieved. If null or not given, an unbounded key range is used. If count is specified and there are more than count keys in range, only the first count will be retrieved.

`count(query)@m ~method手続きは： ◎ The count(query) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.
3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る~recordを数える$( コレ↗, %範囲 ) ◎ Let operation be an algorithm to run count the records in a range with store and range. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$たちが数えられる。 ~NULL または省略時には，`全範囲$が利用される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the records to be counted. If null or not given, an unbounded key range is used.

`openCursor(query, direction)@m ~method手続きは： ◎ The openCursor(query, direction) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.
3. %要請 ~LET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `~cursorを作成する$( コレ, `現在の~realm$, %direction, %範囲 ) ◎ Let cursor be a new cursor with its transaction set to transaction, undefined position, direction set to direction, got value flag set to false, undefined key and value, source set to store, range set to range, and key only flag set to false. ◎ Let operation be an algorithm to run iterate a cursor with the current Realm record and cursor. ◎ Let request be the result of running asynchronously execute a request with this and operation.
4. コレの`要請$Cs ~SET %要請 ◎ Set cursor’s request to request.
5. ~RET %要請 ◎ Return request.

注記： %query ~parameterは、 `~cursor$の`範囲$Csとして利用する［ `~key$／`~key範囲$ ］をとり得る。 ~NULL または省略時には，`全範囲$が利用される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) to use as the cursor’s range. If null or not given, an unbounded key range is used.

`openKeyCursor(query, direction)@m ~method手続きは： ◎ The openKeyCursor(query, direction) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.
3. %要請 ~LET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `~cursorを作成する$( コレ, `現在の~realm$, %direction, %範囲, `~keyのみ^i ) ◎ Let cursor be a new cursor with its transaction set to transaction, undefined position, direction set to direction, got value flag set to false, undefined key and value, source set to store, range set to range, and key only flag set to true. ◎ Let operation be an algorithm to run iterate a cursor with the current Realm record and cursor. ◎ Let request be the result of running asynchronously execute a request with this and operation.
4. コレの`要請$Cs ~SET %要請 ◎ Set cursor’s request to request.
5. ~RET %要請 ◎ Return request.

注記： %query ~parameterは、 `~cursor$の`範囲$Csとして利用する［ `~key$／`~key範囲$ ］をとり得る。 ~NULL または省略時には，`全範囲$が利用される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) to use as the cursor’s range. If null or not given, an unbounded key range is used.

`createIndex(name, keyPath, options)@m ~method手続きは： ◎ The createIndex(name, keyPath, options) method steps are:

1. `状態を検査する$( コレ, `versionchange^l ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If transaction is not an upgrade transaction, throw an "InvalidStateError" DOMException. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. ~IF［ コレの`索引~集合$OsHに［ `名前$Ix ~EQ %name ］なる`索引$がある ］ ⇒ ~THROW `ConstraintError$E ◎ If an index named name already exists in store, throw a "ConstraintError" DOMException.
3. ~IF［ %keyPath は`妥当な~key~path$でない ］ ⇒ ~THROW `SyntaxError$E ◎ If keyPath is not a valid key path, throw a "SyntaxError" DOMException.
4. %一意か ~LET %options[ "`unique$mb" ] ◎ Let unique be options’s unique member.
5. %複-~entryか ~LET %options[ "`multiEntry$mb" ] ◎ Let multiEntry be options’s multiEntry member.
6. ~IF［ %keyPath は`~SeqDS$ 型である ］~AND［ %複-~entryか ~EQ ~T ］ ⇒ ~THROW `InvalidAccessError$E ◎ If keyPath is a sequence and multiEntry is true, throw an "InvalidAccessError" DOMException.
7. %索引 ~LET 新たな`索引$† — その ⇒＃ コレ↗に`専属する$, `名前$Ix ~SET %name, `~key~path$Ix ~SET %keyPath, `一意か$Ix ~SET %一意か, `複-~entryか$Ix ~SET %複-~entryか ◎ Let index be a new index in store. Set index’s name to name, key path to keyPath, unique flag to unique, and multiEntry flag to multiEntry.
8. %索引 をコレの`索引~集合$OsHに追加する ◎ Add index to this’s index set.
9. ~RET 次のようにされた，新たな`索引~handle$ %H ⇒＃ %H↗ ~EQ %索引, %H はコレに`専属する$, `名前$IxH ~SET %name ◎ Return a new index handle associated with index and this.

【† 索引の`~record~list$Ixは、 自動的にコレの`~record~list$Osにより拡充されることになる。 】

この~methodは、 コレに`専属する$, 名前 %name の新たな`索引$を作成した上で、 それを`~access先$とする 新たな`索引~handle$を返す。 この~methodを~callできるのは、 `昇格~txの中$からに限られることに注意。 ◎ This method creates and returns a new index with the given name in the object store. Note that this method must only be called from within an upgrade transaction.

作成するよう要請された索引は、［ 自身が`専属する$`保管庫$に許容される~data ］についての拘束を伴うこともある — 索引の［ `一意か$Ix ~EQ ~T ］により，索引の`~key~path$Ixが指す部位の値（`参照先~record$の値）の一意性が要求されるなど。 その保管庫が，この拘束に違反する~dataをすでに包含している場合でも、 実装は，［ この~methodにて例外を投出したり，それが返すものに影響させる ］ことなく， `IDBIndex^I ~objを作成して返すモノトスル。 代わりに実装は、［ この~methodの~callに利用された，`昇格~tx$ ］を中止する`~taskを~queueする$モノトスル。 ◎ The index that is requested to be created can contain constraints on the data allowed in the index’s referenced object store, such as requiring uniqueness of the values referenced by the index’s key path. If the referenced object store already contains data which violates these constraints, this must not cause the implementation of createIndex() to throw an exception or affect what it returns. The implementation must still create and return an IDBIndex object, and the implementation must queue a task to abort the upgrade transaction which was used for the createIndex() call.

この~methodは、 コレ上の `indexNames$m ~propを同期的に改変する。 この~methodは `IDBRequest$I ~objを返さないが、 索引の作成~自体は，`昇格~tx$の中の非同期的な要請として，処理される。 ◎ This method synchronously modifies the indexNames property on the IDBObjectStore instance on which it was called. Although this method does not return an IDBRequest object, the index creation itself is processed as an asynchronous request within the upgrade transaction.

実装によっては、 この~methodが`索引~handle$（ `IDBIndex^I ~obj）を返した後，`索引$を非同期に作成するときに，問題になる可能性がある。 例えば、［ 新たに作成された索引の~metadataを~dbに挿入する~taskを~queueする所 ］，あるいは［ ~quota事由から，利用者に許可を請う必要があり得る所 ］で。 そのような場合でも，実装は： ◎ In some implementations it is possible for the implementation to asynchronously run into problems creating the index after the createIndex method has returned. For example in implementations where metadata about the newly created index is queued up to be inserted into the database asynchronously, or where the implementation might need to ask the user for permission for quota reasons. Such implementations＼

• `索引~handle$を作成して返すモノトスル。 ◎ must still create and return an IDBIndex object,＼

• 加えて，`索引$の作成ngに失敗したときは、 次を走らすモノトスル ⇒ `~txを中止する$( コレ, 失敗の事由に適切な~error名† ) ◎ and once the implementation determines that creating the index has failed, it must run the steps to abort a transaction using an appropriate error.＼

  † 例えば、［ ~quota事由に因り`索引$の作成ngに失敗した場合は `QuotaExceededError$E ／ ［ `一意か$Ix ~EQ ~T ］の拘束に因り索引を作成できない場合は `ConstraintError$E ］を利用するモノトスル。 ◎ For example if creating the index failed due to quota reasons, a "QuotaExceededError" DOMException must be used as error and if the index can’t be created due to unique flag constraints, a "ConstraintError" DOMException must be used as error.

const %request1 = objectStore.put({name: `betty^l}, `1^lt);
const %request2 = objectStore.put({name: `betty^l}, `2^lt);
const %index = objectStore.createIndex(`by_name^l, `name^l, {unique: true});

`index(name)@m ~method手続きは： ◎ The index(name) method steps are:

1. ~IF［ コレ↗は削除されている ］ ⇒ ~THROW `InvalidStateError$E ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If store has been deleted, throw an "InvalidStateError" DOMException.
2. ~IF コレが`専属する$`~tx$の`状態$tx ~EQ `完遂d$i ⇒ ~THROW `InvalidStateError$E ◎ If transaction’s state is finished, then throw an "InvalidStateError" DOMException.
3. %索引 ~LET コレの`索引~集合$OsH 内の`索引$のうち，次を満たすもの ⇒ `名前$Ix ~EQ %name ◎ Let index be the index named name in this’s index set if one exists,＼
4. ~IF［ %索引 ~EQ ε ］ ⇒ ~THROW `NotFoundError$E ◎ or throw a "NotFoundError" DOMException otherwise.
5. ~RET 次を満たすような`索引~handle$ %H ⇒＃ %H↗ ~EQ %索引, %H はコレに`専属する$, `一意性$の要件を満たす ◎終 （`可換性$の要件は、`索引~集合$OsHの構成から自動的に満たされる） ◎ Return an index handle associated with index and this.

注記： `一意性$の要件から，返される~instanceは一意に定まる 【~instanceがその前のどの時点で作成されるかは，実装の詳細~になる】 。 よって、 `昇格~tx$の間を除き、 同じ `IDBObjectStore$I ~instance上で，同じ %name をこの~methodに渡して返される `IDBIndex$I ~instanceは、 常に同じになる。 ◎ NOTE: Each call to this method on the same IDBObjectStore instance with the same name returns the same IDBIndex instance.

注記： %H はコレに`専属する$ので、 他の `IDBObjectStore$I ~instanceに対し同じ %name で この~methodを呼出しても， %H と異なる `IDBIndex$I ~instanceが返される。 ◎ NOTE: The returned IDBIndex instance is specific to this IDBObjectStore instance. If this method is called on a different IDBObjectStore instance with the same name, a different IDBIndex instance is returned.

`deleteIndex(name)@m ~method手続きは： ◎ The deleteIndex(name) method steps are:

1. `状態を検査する$( コレ, `versionchange^l ) ？ ◎ Let transaction be this’s transaction. ◎ Let store be this’s object store. ◎ If transaction is not an upgrade transaction, throw an "InvalidStateError" DOMException. ◎ If store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %索引 ~LET コレ↗に`専属する$`索引$のうち，次を満たすもの ⇒ `名前$Ix ~EQ %name ◎ Let index be the index named name in store if one exists,＼
3. ~IF［ %索引 ~EQ ε ］ ⇒ ~THROW `NotFoundError$E ◎ or throw a "NotFoundError" DOMException otherwise.
4. コレの`索引~集合$OsHから %索引 を除去する ◎ Remove index from this’s index set.
5. %索引 を破壊する ◎ Destroy index.

この~methodは、 コレ↗に専属する，名前 %name の`索引$を破壊する。 この~methodを~callできるのは、 `昇格~txの中$からに限られることに注意。 ◎ This method destroys the index with the given name in the object store. Note that this method must only be called from within an upgrade transaction.

この~methodは、 コレ上の `indexNames$m 属性を同期的に改変する。 この~methodは `IDBRequest$I ~objを返さないが、 索引の破壊~自体は，`昇格~tx$の中で非同期的な要請として処理される。 ◎ This method synchronously modifies the indexNames property on the IDBObjectStore instance on which it was called. Although this method does not return an IDBRequest object, the index destruction itself is processed as an asynchronous request within the upgrade transaction.

`name@m 取得子~手続きは ⇒ ~RET コレの`名前$IxH ◎ The name getter steps are to return this’s name.

注記： コレが`専属する$~txが`完遂-$していない限り、 返される値はコレ↗の`名前$Ixと同じになり、 それ以降も同じ`値を保ち続ける$。 【！ deitails 】 ◎ Is this the same as the index’s name? ◎ As long as the transaction has not finished, this is the same as the associated index’s name. But once the transaction has finished, this attribute will not reflect changes made with a later upgrade transaction.

`name$m 設定子~手続きは： ◎ The name setter steps are:

1. `状態を検査する$( コレ, `versionchange^l ) ？ ◎ Let name be the given value. ◎ Let transaction be this’s transaction. ◎ Let index be this’s index. ◎ If transaction is not an upgrade transaction, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ 変則＊ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException.
2. %name ~LET `所与の値$ ◎ ↑
3. ~IF［ コレの`名前$IxH ~EQ %name ］ ⇒ ~RET ◎ If index’s name is equal to name, terminate these steps.
4. ~IF［［ コレが`専属する$`保管庫~handle$ ］の`索引~集合$OsHに［ `名前$IxH ~EQ %name ］なる`索引$がある ］ ⇒ ~THROW `ConstraintError$E ◎ If an index named name already exists in index’s object store, throw a "ConstraintError" DOMException.
5. コレ↗の`名前$Ix ~SET %name ◎ Set index’s name to name.
6. コレの`名前$IxH ~SET %name ◎ Set this’s name to name.

`keyPath@m 取得子~手続きは ⇒ ~RET コレ↗の`~key~path$Ix %P を `WEBIDL$r に従って，次の型として変換した結果 ⇒＃ %P は文字列であるならば `DOMString$I ／ %P は文字列たちが成す~listであるならば `~SeqDS$ ◎ The keyPath getter steps are to return this’s index’s key path. The key path is converted as a DOMString (if a string) or a sequence<DOMString> (if a list of strings), per [WEBIDL].

【この属性は、`値を保ち続ける$。】

注記： 返される値は、 コレの作成-時に利用した~instanceと同じではない。 しかしながら，この属性が~obj（特定的には `Array$jT ）を返す場合、 毎回~同じ~instanceを返す。 返された~objの~prop値を変更しても，コレに効果を及ぼすことはない。 ◎ NOTE: The returned value is not the same instance that was used when the index was created. However, if this attribute returns an object (specifically an Array), it returns the same object instance every time it is inspected. Changing the properties of the object has no effect on the index.

`multiEntry@m 取得子~手続きは ⇒ ~RET コレ↗の`複-~entryか$Ix ◎ The multiEntry getter steps are to return this’s index’s multiEntry flag.

【この属性は、`値を保ち続ける$。】

`unique@m 取得子~手続きは ⇒ ~RET コレ↗の`一意か$Ix ◎ The unique getter steps are to return this’s index’s unique flag.

【この属性は、`値を保ち続ける$。】

`get(query)@m ~method手続きは： ◎ The get(query) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let index be this’s index. ◎ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query, `~NULL不可^i ) ？ ◎ Let range be the result of converting a value to a key range with query and true. Rethrow any exceptions.
3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る最初の~entryを検索取得する$( コレ↗, %範囲, `値^i ) ◎ Let operation be an algorithm to run retrieve a referenced value from an index with the current Realm record, index, and range. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$ （範囲が指定された場合、 範囲に入る最初の既存の~record） の`値$が検索取得される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the referenced value to be retrieved. If a range is specified, the method retrieves the first existing record in that range.

注記： `IDBObjectStore.get()$m の注記にて述べたことが，この~methodにも該当する。 ◎ NOTE: This method produces the same result if a record with the given key doesn’t exist as when a record exists, but has undefined as value. If you need to tell the two situations apart, you can use openCursor() with the same key. This will return a cursor with undefined as value if a record exists, or no cursor if no such record exists.

`getKey(query)@m ~method手続きは： ◎ The getKey(query) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let index be this’s index. ◎ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query, `~NULL不可^i ) ？ ◎ Let range be the result of converting a value to a key range with query and true. Rethrow any exceptions.
3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る最初の~entryを検索取得する$( コレ↗, %範囲, `~key^i ) ◎ Let operation be an algorithm to run retrieve a value from an index with index and range. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$ （範囲が指定された場合、 範囲に入る最初の既存の~record） の`~key$が検索取得される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the record key to be retrieved. If a range is specified, the method retrieves the first existing key in that range.

`getAll(query, count)@m ~method手続きは： ◎ The getAll(query, count) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let index be this’s index. ◎ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.
3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る~entryたちを検索取得する$( コレ↗, %範囲, %count, `値^i ) ◎ Let operation be an algorithm to run retrieve multiple referenced values from an index with the current Realm record, index, range, and count if given. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$たちの`参照先~record$の`値$が検索取得される。 ~NULL または省略時には，`全範囲$が利用される。 %count が指定されていて，範囲に入る~record数がそれを超える場合、 最初から %count 個までが検索取得される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the referenced values to be retrieved. If null or not given, an unbounded key range is used. If count is specified and there are more than count records in range, only the first count will be retrieved.

`getAllKeys(query, count)@m ~method手続きは： ◎ The getAllKeys(query, count) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let index be this’s index. ◎ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.
3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る~entryたちを検索取得する$( コレ↗, %範囲, %count, `~key^i ) ◎ Let operation be an algorithm to run retrieve multiple values from an index with index, range, and count if given. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$たち【の`参照先~record$】の`~key$が検索取得される。 ~NULL または省略時には，`全範囲$が利用される。 %count が指定されていて，範囲に入る~key数がそれを超える場合、 最初から %count 個までが検索取得される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the record keys to be retrieved. If null or not given, an unbounded key range is used. If count is specified and there are more than count keys in range, only the first count will be retrieved.

`count(query)@m ~method手続きは： ◎ The count(query) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let index be this’s index. ◎ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.
3. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `範囲に入る~recordを数える$( コレ↗, %範囲 ) ◎ Let operation be an algorithm to run count the records in a range with index and range. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

注記： %query ~parameterは、［ `~key$／`~key範囲$ ］をとり得る — それにより識別される`~record$たちが数えられる。 ~NULL または省略時には，`全範囲$が利用される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) identifying the records to be counted. If null or not given, an unbounded key range is used.

`openCursor(query, direction)@m ~method手続きは： ◎ The openCursor(query, direction) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let index be this’s index. ◎ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.
3. %要請 ~LET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `~cursorを作成する$( コレ, `現在の~realm$, %direction, %範囲 ) ◎ Let cursor be a new cursor with its transaction set to transaction, undefined position, direction set to direction, got value flag set to false, undefined key and value, source set to index, range set to range, and key only flag set to false. ◎ Let operation be an algorithm to run iterate a cursor with the current Realm record and cursor. ◎ Let request be the result of running asynchronously execute a request with this and operation.
4. コレの`要請$Cs ~SET %要請 ◎ Set cursor’s request to request.
5. ~RET %要請 ◎ Return request.

注記： %query ~parameterは、 `~cursor$の`範囲$Csとして利用する［ `~key$／`~key範囲$ ］をとり得る。 ~NULL または省略時には，`全範囲$が利用される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) to use as the cursor’s range. If null or not given, an unbounded key range is used.

`openKeyCursor(query, direction)@m ~method手続きは： ◎ The openKeyCursor(query, direction) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ Let index be this’s index. ◎ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
2. %範囲 ~LET `Range$( %query ) ？ ◎ Let range be the result of converting a value to a key range with query. Rethrow any exceptions.
3. %要請 ~LET 次の`演算$を走らす`要請を非同期に実行する$( コレ ) ⇒ `~cursorを作成する$( コレ, `現在の~realm$, %direction, %範囲, `~keyのみ^i ) ◎ Let cursor be a new cursor with its transaction set to transaction, undefined position, direction set to direction, got value flag set to false, undefined key and value, source set to index, range set to range, and key only flag set to true. ◎ Let operation be an algorithm to run iterate a cursor with the current Realm record and cursor. ◎ Let request be the result of running asynchronously execute a request with this and operation.
4. コレの`要請$Cs ~SET %要請 ◎ Set cursor’s request to request.
5. ~RET %要請 ◎ Return request.

注記： %query ~parameterは、 `~cursor$の`範囲$Csとして利用する［ `~key$／`~key範囲$ ］をとり得る。 ~NULL または省略時には，`全範囲$が利用される。 ◎ NOTE: The query parameter can be a key or key range (an IDBKeyRange) to use as the cursor’s range. If null or not given, an unbounded key range is used.

`lowerBound(lower, open)@m ~method手続きは： ◎ The lowerBound(lower, lowerOpen) method steps are:

1. %lowerKey ~LET `Key$( %lower ) ？ ◎ Let lowerKey be the result of converting a value to a key with lower. Rethrow any exceptions. ◎ If lowerKey is invalid, throw a "DataError" DOMException.
2. ~RET 新たな`~key範囲$ — その ⇒＃ `下界$ ~SET %lowerKey, `下界openか$ ~SET %open, `上界$ ~SET ε, `上界openか$ ~SET ~T ◎ Create and return a new key range with lower bound set to lowerKey, lower open flag set to open, upper bound set to null, and upper open flag set to true.

`upperBound(upper, open)@m ~method手続きは： ◎ The upperBound(upper, open) method steps are:

1. %upperKey ~LET `Key$( %upper ) ？ ◎ Let upperKey be the result of converting a value to a key with upper. Rethrow any exceptions. ◎ If upperKey is invalid, throw a "DataError" DOMException.
2. ~RET 新たな`~key範囲$ — その ⇒＃ `下界$ ~SET ε, `下界openか$ ~SET ~T, `上界$ ~SET %upperKey, `上界openか$ ~SET %open ◎ Create and return a new key range with lower bound set to null, lower open flag set to true, upper bound set to upperKey, and upper open flag set to open.

`bound(lower, upper, lowerOpen, upperOpen)@m ~method手続きは： ◎ The bound(lower, upper, lowerOpen, upperOpen) method steps are:

1. %lowerKey ~LET `Key$( %lower ) ？ ◎ Let lowerKey be the result of converting a value to a key with lower. Rethrow any exceptions. ◎ If lowerKey is invalid, throw a "DataError" DOMException.
2. %upperKey ~LET `Key$( %upper ) ？ ◎ Let upperKey be the result of converting a value to a key with upper. Rethrow any exceptions. ◎ If upperKey is invalid, throw a "DataError" DOMException.
3. ~IF［ %lower ~GT~cmpkey %upper ］ ⇒ ~THROW `DataError$E ◎ If lowerKey is greater than upperKey, throw a "DataError" DOMException.
4. ~RET 新たな`~key範囲$ — その ⇒＃ `下界$ ~SET %lowerKey, `下界openか$ ~SET %lowerOpen, `上界$ ~SET %upperKey, `上界openか$ ~SET %upperOpen ◎ Create and return a new key range with lower bound set to lowerKey, lower open flag set to lowerOpen, upper bound set to upperKey and upper open flag set to upperOpen.

`includes(key)@m ~method手続きは： ◎ The includes(key) method steps are:

1. %key ~LET `Key$( %key ) ？ ◎ Let k be the result of converting a value to a key with key. Rethrow any exceptions. ◎ If k is invalid, throw a "DataError" DOMException.
2. ~IF ［ %key ~IN~cmpkey コレ ］ ⇒ ~RET ~T ◎ Return true if k is in this range, and＼
3. ~RET ~F ◎ false otherwise.

`source@m 取得子~手続きは ⇒ ~RET コレの`~source$Cs ◎ The source getter steps are to return this’s source.

注記： コレの`~source$Cs %S は、 `コレを作成する＠#_X-new-cursor$よう要請した［ `保管庫~handle$／`索引~handle$ ］に初期化され， それ以降は変化しない — %S が`専属する$~txが `作動中$i でなくなっても， %S↗ が破壊されても。 ◎ NOTE: The source attribute never returns null or throws an exception, even if the cursor is currently being iterated, has iterated past its end, or its transaction is not active.

`key@m 取得子~手続きは ⇒ ~RET `Value$( コレの`~key$Cs ) ◎ The key getter steps are to return the result of converting a key to a value with the cursor’s current key.

注記： ~obj（ `Date$jT や `Array$jT など）を返す場合、 コレの`~key$Cs が変更されるまで，毎回~同じ~instanceを返すことになる。 すなわち、 ~objに加えられる改変は，どこからも見えることになる — しかしながら、 その改変が~dbの内容を改変することはない。 ◎ NOTE: If key returns an object (e.g. a Date or Array), it returns the same object instance every time it is inspected, until the cursor’s key is changed. This means that if the object is modified, those modifications will be seen by anyone inspecting the value of the cursor. However modifying such an object does not modify the contents of the database.

`primaryKey@m 取得子~手続きは ⇒ ~RET `Value$( コレの`実効~key$Cs ) ◎ The primaryKey getter steps are to return the result of converting a key to a value with the cursor’s current effective key.

注記： `key^m 取得子の`注記＠#_key-getter-return-value$は、 この取得子にも該当する。 ◎ NOTE: If primaryKey returns an object (e.g. a Date or Array), it returns the same object instance every time it is inspected, until the cursor’s effective key is changed. This means that if the object is modified, those modifications will be seen by anyone inspecting the value of the cursor. However modifying such an object does not modify the contents of the database.

`request@m 取得子~手続きは ⇒ ~RET コレの`要請$Cs ◎ The request getter steps are to return this’s request.

🚧 これは、 この版による新たな属性である。 ［ Chrome 76, Edge 79, Firefox 77, Safari 15 ］から~supportされている。 🚧 ◎ 🚧 The request attribute is new in this edition. It is supported in Chrome 76, Edge 79, Firefox 77, and Safari 15. 🚧

`advance(count)@m ~method手続きは： ◎ The advance(count) method steps are:

1. ~IF［ %count ~EQ 0 ］ ⇒ ~THROW `TypeError$E ◎ If count is 0 (zero), throw a TypeError.
2. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ If this’s source or effective object store has been deleted, throw an "InvalidStateError" DOMException.
3. ~IF［ コレの`値は取得-済みか$Cs ~EQ ~F ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s got value flag is false, indicating that the cursor is being iterated or has iterated past its end, throw an "InvalidStateError" DOMException.
4. コレの`値は取得-済みか$Cs ~SET ~F ◎ Set this’s got value flag to false.
5. %要請 ~SET コレの`要請$Cs ◎ Let request be this’s request.
6. %要請 の ⇒＃ `処理-済みか$ ~SET ~F, `済んだか$ ~SET ~F ◎ Set request’s processed flag to false. ◎ Set request’s done flag to false.
7. 次の`演算$を走らす`要請を非同期に実行する$( コレの`~source$Cs, %要請 ) ⇒ `~cursorを反復する$( コレ, `現在の~realm$, ε, ε, %count ) ◎ Let operation be an algorithm to run iterate a cursor with the current Realm record, this, and count. ◎ Run asynchronously execute a request with this’s source, operation, and request.

注記： 新たな~cursor~dataが読込まれる前に，この~methodを重ねて~callした場合 — 例えば，同じ `onsuccess^m ~handlerの~callの中で重ねて~callした場合 — 2 回目の~call時には、 ~cursorの`値は取得-済みか$Cs ~EQ ~F なので， `InvalidStateError$E 例外が投出されることになる。 ◎ NOTE: Calling this method more than once before new cursor data has been loaded - for example, calling advance() twice from the same onsuccess handler - results in an "InvalidStateError" DOMException being thrown on the second call because the cursor’s got value flag has been set to false.

`continue(key)@m ~method手続きは： ◎ The continue(key) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ If this’s source or effective object store has been deleted, throw an "InvalidStateError" DOMException.
2. ~IF［ コレの`値は取得-済みか$Cs ~EQ ~F ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s got value flag is false, indicating that the cursor is being iterated or has iterated past its end, throw an "InvalidStateError" DOMException.

3. ~IF［ %key ~NEQ ε ］： ◎ If key is given, then:

   1. %key ~LET `Key$( %key ) ？ ◎ Let r be the result of converting a value to a key with key. Rethrow any exceptions. ◎ If r is invalid, throw a "DataError" DOMException. ◎ Let key be r.
   2. ~IF［ %key ~LTE~cmpkey コレの`位置$Cs ］~AND［ コレの`方向$Cs ~IN { `next^l, `nextunique^l } ］ ⇒ ~THROW `DataError$E ◎ If key is less than or equal to this’s position and this’s direction is "next" or "nextunique", then throw a "DataError" DOMException.
   3. ~IF［ %key ~GTE~cmpkey コレの`位置$Cs ］~AND［ コレの`方向$Cs ~IN { `prev^l, `prevunique^l } ］ ⇒ ~THROW `DataError$E ◎ If key is greater than or equal to this’s position and this’s direction is "prev" or "prevunique", then throw a "DataError" DOMException.
4. コレの`値は取得-済みか$Cs ~SET ~F ◎ Set this’s got value flag to false.
5. %要請 ~SET コレの`要請$Cs ◎ Let request be this’s request.
6. %要請 の ⇒＃ `処理-済みか$ ~SET ~F, `済んだか$ ~SET ~F ◎ Set request’s processed flag to false. ◎ Set request’s done flag to false.
7. 次の`演算$を走らす`要請を非同期に実行する$( コレの`~source$Cs, %要請 ) ⇒ `~cursorを反復する$( コレ, `現在の~realm$, %key ) ◎ Let operation be an algorithm to run iterate a cursor with the current Realm record, this, and key (if given). ◎ Run asynchronously execute a request with this’s source, operation, and request.

注記： `advance$m の注記と同じ文言がこの~methodにも該当する。 ◎ NOTE: Calling this method more than once before new cursor data has been loaded - for example, calling continue() twice from the same onsuccess handler - results in an "InvalidStateError" DOMException being thrown on the second call because the cursor’s got value flag has been set to false.

`continuePrimaryKey(key, primaryKey)@m ~method手続きは： ◎ The continuePrimaryKey(key, primaryKey) method steps are:

1. `状態を検査する$( コレ ) ？ ◎ Let transaction be this’s transaction. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ If this’s source or effective object store has been deleted, throw an "InvalidStateError" DOMException.
2. ~IF［ コレの`~source$Csは`索引~handle$でない ］ ⇒ ~THROW `InvalidAccessError$E ◎ If this’s source is not an index throw an "InvalidAccessError" DOMException.
3. ~IF［ コレの`方向$Cs ~NIN { `next^l, `prev^l } ］ ⇒ ~THROW `InvalidAccessError$E ◎ If this’s direction is not "next" or "prev", throw an "InvalidAccessError" DOMException.
4. ~IF［ コレの`値は取得-済みか$Cs ~EQ ~F ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s got value flag is false, indicating that the cursor is being iterated or has iterated past its end, throw an "InvalidStateError" DOMException.
5. %key ~LET `Key$( %key ) ？ ◎ Let r be the result of converting a value to a key with key. Rethrow any exceptions. ◎ If r is invalid, throw a "DataError" DOMException. ◎ Let key be r.
6. %首key ~LET `Key$( %primaryKey ) ？ ◎ Let r be the result of converting a value to a key with primaryKey. Rethrow any exceptions. ◎ If r is invalid, throw a "DataError" DOMException. ◎ Let primaryKey be r.
7. ~IF［ コレの`方向$Cs ~EQ `next^l ］~AND［ ( %key, %首key ) ~LTE~cmpkey コレの ( `位置$Cs, `保管庫~位置$Cs ) ］ ⇒ ~THROW `DataError$E ◎ ↓
8. ~IF［ コレの`方向$Cs ~EQ `prev^l ］~AND［ ( %key, %首key ) ~GTE~cmpkey コレの ( `位置$Cs, `保管庫~位置$Cs ) ］ ⇒ ~THROW `DataError$E ◎ If key is less than this’s position and this’s direction is "next", throw a "DataError" DOMException. ◎ If key is greater than this’s position and this’s direction is "prev", throw a "DataError" DOMException. ◎ If key is equal to this’s position and primaryKey is less than or equal to this’s object store position and this’s direction is "next", throw a "DataError" DOMException. ◎ If key is equal to this’s position and primaryKey is greater than or equal to this’s object store position and this’s direction is "prev", throw a "DataError" DOMException.
9. コレの`値は取得-済みか$Cs ~SET ~F ◎ Set this’s got value flag to false.
10. %要請 ~SET コレの`要請$Cs ◎ Let request be this’s request.
11. %要請 の ⇒＃ `処理-済みか$ ~SET ~F, `済んだか$ ~SET ~F ◎ Set request’s processed flag to false. ◎ Set request’s done flag to false.
12. 次の`演算$を走らす`要請を非同期に実行する$( コレの`~source$Cs, %要請 ) ⇒ `~cursorを反復する$( コレ, `現在の~realm$, %key, %首key ) ◎ Let operation be an algorithm to run iterate a cursor with the current Realm record, this, key, and primaryKey. ◎ Run asynchronously execute a request with this’s source, operation, and request.

注記： `advance$m の注記と同じ文言がこの~methodにも該当する。 ◎ NOTE: Calling this method more than once before new cursor data has been loaded - for example, calling continuePrimaryKey() twice from the same onsuccess handler - results in an "InvalidStateError" DOMException being thrown on the second call because the cursor’s got value flag has been set to false.

`update(value)@m ~method手続きは： ◎ The update(value) method steps are:

1. `状態を検査する$( コレ, `readwrite^l ) ？ ◎ Let transaction be this’s transaction. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ If transaction is a read-only transaction, throw a "ReadOnlyError" DOMException. ◎ If this’s source or effective object store has been deleted, throw an "InvalidStateError" DOMException.
2. ~IF［ コレの`値は取得-済みか$Cs ~EQ ~F ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s got value flag is false, indicating that the cursor is being iterated or has iterated past its end, throw an "InvalidStateError" DOMException.
3. ~IF［ コレの`~keyのみか$Cs ~EQ ~T ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s key only flag is true, throw an "InvalidStateError" DOMException.
4. %clone ~LET `~txの間に値を~cloneする$( %value, コレの`~source$Csが`専属する$`~tx$ ) ？ ◎ Let targetRealm be a user-agent defined Realm. ◎ Let clone be a clone of value in targetRealm during transaction. Rethrow any exceptions. ◎ Why create a copy of the value? ◎ The value is serialized when stored. Treating it as a copy here allows other algorithms in this specification to treat it as an ECMAScript value, but implementations can optimize this if the difference in behavior is not observable.
5. %keyPath ~LET コレの`実効~保管庫$Csの`~key~path$Os ◎ ↓

6. ~IF［ %keyPath ~NEQ ε ］：

   1. %抽出d~key ~LET `Extract$( %clone, %keyPath ) ？
   2. ~IF［ %抽出d~key ~NEQ~cmpkey ~cursorの`実効~key$Cs ］ ⇒ ~THROW `DataError$E ◎ ↑
   ◎ If this’s effective object store uses in-line keys, then: • Let kpk be the result of extracting a key from a value using a key path with clone and the key path of this’s effective object store. Rethrow any exceptions. • If kpk is failure, invalid, or not equal to this’s effective key, throw a "DataError" DOMException.

7. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレの`~source$Cs ) ⇒ `保管庫に~recordを格納する$( コレの`実効~保管庫$Cs, %clone, コレの`実効~key$Cs ) ◎ Let operation be an algorithm to run store a record into an object store with this’s effective object store, clone, this’s effective key, and false. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

   注記： `保管庫に~recordを格納する$演算は、［ ~cursorを ある~recordを指す位置に移動した後，その~recordが削除されていた場合 ］には，新たな~recordを作成することになる。 ◎ NOTE: A result of storing a record into an object store is that if the record has been deleted since the cursor moved to it, a new record will be created.

`delete()@m ~method手続きは： ◎ The delete() method steps are:

1. `状態を検査する$( コレ, `readwrite^l ) ？ ◎ Let transaction be this’s transaction. ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException. ◎ If transaction is a read-only transaction, throw a "ReadOnlyError" DOMException. ◎ If this’s source or effective object store has been deleted, throw an "InvalidStateError" DOMException.
2. ~IF［ コレの`値は取得-済みか$Cs ~EQ ~F ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s got value flag is false, indicating that the cursor is being iterated or has iterated past its end, throw an "InvalidStateError" DOMException.
3. ~IF［ コレの`~keyのみか$Cs ~EQ ~T ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s key only flag is true, throw an "InvalidStateError" DOMException.
4. ~RET 次の`演算$を走らす`要請を非同期に実行する$( コレの`~source$Cs ) ⇒ `保管庫から~recordを削除する$( コレの`実効~保管庫$Cs, `Only$( コレの`実効~key$Cs ) ) ◎ Let operation be an algorithm to run delete records from an object store with this’s effective object store and this’s effective key. ◎ Return the result (an IDBRequest) of running asynchronously execute a request with this and operation.

`value@m 取得子~手続きは ⇒ ~RET ［ コレの`値$Cs ~NEQ ε ならば それ ／ ~ELSE_ `undefined^jv ］ ◎ The value getter steps are to return this’s current value.

注記： `key^m 取得子の`注記＠#_key-getter-return-value$は、 この取得子にも該当する。 ◎ NOTE: If value returns an object, it returns the same object instance every time it is inspected, until the cursor’s value is changed. This means that if the object is modified, those modifications will be seen by anyone inspecting the value of the cursor. However modifying such an object does not modify the contents of the database.

`objectStoreNames@m 取得子~手続きは： ◎ The objectStoreNames getter steps are:

1. %名前~群 ~LET ［ コレが`視野$に入れている各`保管庫$の`名前$Os ］たちが成す`~list$ ◎ Let names be a list of the names of the object stores in this’s scope.
2. ~RET `~sort済み名前~listを作成する$( %名前~群 ) ◎ Return the result (a DOMStringList) of creating a sorted name list with names.

注記： この属性が返す~listの内容は、 変化しない — ただし，`昇格~tx$の間は、 保管庫が［ 作成される／削除される ］に伴い変化し得る。 ◎ NOTE: The contents of each list returned by this attribute does not change, but subsequent calls to this attribute during an upgrade transaction can return lists with different contents as object stores are created and deleted.

`durability@m 取得子~手続きは ⇒ ~RET コレの`耐久能~hint$ ◎ The durability getter steps are to return this’s durability hint.

🚧 これは、 この版による新たな属性である。 ［ Chrome 82, Edge 82, Firefox 126, Safari 15 ］から~supportされている。 🚧 ◎ 🚧 The durability attribute is new in this edition. It is supported in Chrome 82, Edge 82, Firefox 126, and Safari 15. 🚧

`error@m 取得子~手続きは ⇒ ~RET ［ コレの`~error$tx ~NEQ ε ならば それ ／ ~ELSE_ ~NULL ］ ◎ The error getter steps are to return this’s error, or null if none.

`objectStore(name)@m ~method手続きは： ◎ The objectStore(name) method steps are:

1. ~IF［ コレの`状態$tx ~EQ `完遂d$i ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s state is finished, then throw an "InvalidStateError" DOMException.
2. %保管庫 ~LET 次を満たす`保管庫$ ⇒ ［ コレの`視野$に入る ］~AND［ `名前$Os ~EQ %name ］ ◎ Let store be the object store named name in this’s scope,＼
3. ~IF［ %保管庫 ~EQ ε ］ ⇒ ~THROW `NotFoundError$E ◎ or throw a "NotFoundError" DOMException if none.
4. ~RET 次を満たすような`保管庫~handle$ %H ⇒＃ %H↗ ~EQ %保管庫, %H はコレに`専属する$, `一意性$の要件を満たす ◎終 （`可換性$の要件は、`視野$の構成から自動的に満たされる） ◎ Return an object store handle associated with store and this.

注記： `一意性$の要件から，返される~instanceは一意に定まる 【~instanceがその前のどの時点で作成されるかは，実装の詳細~になる】 。 よって、 `昇格~tx$の間を除き、 同じ `IDBTransaction$I ~instance上で，同じ %name をこの~methodに渡して返される `IDBObjectStore$I ~instanceは、 常に同じになる。 ◎ NOTE: Each call to this method on the same IDBTransaction instance with the same name returns the same IDBObjectStore instance.

注記： %H はコレに`専属する$ので、 他の `IDBTransaction$I ~instanceに対し同じ引数で この~methodを呼出しても， %H と異なる `IDBObjectStore$I ~instanceが返される。 ◎ NOTE: The returned IDBObjectStore instance is specific to this IDBTransaction. If this method is called on a different IDBTransaction, a different IDBObjectStore instance is returned.

`abort()@m ~method手続きは： ◎ The abort() method steps are:

1. ~IF［ コレの`状態$tx ~IN { `~commit中$i, `完遂d$i } ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s state is committing or finished, then throw an "InvalidStateError" DOMException.
2. コレの`状態$tx ~SET `非作動中$i ◎ Set this’s state to inactive and＼
3. `~txを中止する$( コレ, ~NULL ) ◎ run abort a transaction with this and null.

`commit()@m ~method手続きは： ◎ The commit() method steps are:

1. ~IF［ コレの`状態$tx ~NEQ `作動中$i ］ ⇒ ~THROW `InvalidStateError$E ◎ If this’s state is not active, then throw an "InvalidStateError" DOMException.
2. `~txを~commitする$( コレ ) ◎ Run commit a transaction with this.

🚧 これは、 この版による新たな~methodである。 ［ Chrome 76, Edge 79, Firefox 74, Safari 15 ］から~supportされている。 🚧 ◎ 🚧 The commit() method is new in this edition. It is supported in Chrome 76, Edge 79, Firefox 74, and Safari 15. 🚧

注記： `~tx$上でこの~methodを~callすることは、 通常は必要yでない。 ~txは、 未決な要請がすべて満たされ，新たな要請は為されていなければ，自動的に~commitされる。 この~callを利用すれば、 未決な`要請$から配送される~eventを待機することなく，`~commit$処理-を開始できる。 ◎ NOTE: It is not normally necessary to call commit() on a transaction. A transaction will automatically commit when all outstanding requests have been satisfied and no new requests have been made. This call can be used to start the commit process without waiting for events from outstanding requests to be dispatched.

%O を通して［ `保管庫$／`索引$ ］に［ ~accessし得るかどうか, および演算し得るかどうか ］を検査する：

1. ~Assert： %O は［ `保管庫~handle$／`索引~handle$／`~cursor$ ］である

2. ~IF［ %O は`~cursor$である ］：

   1. %O ~SET %O の`~source$Cs
   2. 下の手続きを `段 A^i, `段 C^i, `段 B^i の順に実行する
   3. ~RET
3. `段 A^i：
   1. %~tx ~LET %O が`専属する$~tx
   2. ~IF［ %要求mode ~EQ `versionchange^l ］~AND［ %~tx は`昇格~tx$でない ］ ⇒ ~THROW `InvalidStateError$E ◎ If transaction is not an upgrade transaction, throw an "InvalidStateError" DOMException.
4. `段 B^i：
   1. ~IF［ %O↗ はすでに削除されている ］ ⇒ ~THROW `InvalidStateError$E ◎ If index or index’s object store has been deleted, throw an "InvalidStateError" DOMException. ◎ If store has been deleted, throw an "InvalidStateError" DOMException.
5. `段 C^i：
   1. ~IF［ %~tx の`状態$tx ~NEQ `作動中$i ］ ⇒ ~THROW `TransactionInactiveError$E ◎ If transaction’s state is not active, then throw a "TransactionInactiveError" DOMException.
   2. ~IF［ %要求mode ~EQ `readwrite^l ］~AND［ %~tx は`~readonly~tx$である ］ ⇒ ~THROW `ReadOnlyError$E ◎ If transaction is a read-only transaction, throw a "ReadOnlyError" DOMException.

所与の［ `~key$／ ε ］を値に変換した結果を返す：

1. ~IF［ %key ~EQ ε ］ ⇒ ~RET `undefined^jv
2. ~RET `~keyを値に変換する$( %key )

所与の値を`~key$に変換した結果を返すか例外を`投出-$する：

1. %~key ~LET `値を~keyに変換する$( %入力 ) ？
2. ~IF［ %~key ~EQ `妥当でない^i ］ ⇒ ~THROW `DataError$E
3. ~RET %~key

所与の ( `値$, `~key~path$, `~key生成器$ ) に対し，［ `~key$ ／ ε ］を返すか例外を`投出-$する：

1. %抽出d~key ~LET `値から~keyを抽出する$ ( %値, %~key~path ) ？

2. %抽出d~key に応じて：

   `~key$である

   ~RET %抽出d~key

   `妥当でない^i

   ~THROW `DataError$E

   `失敗^i

   1. ~IF［ %生成器 ~EQ ε ］ ⇒ ~THROW `DataError$E
   2. ~RET ε

   ◎ Let kpk be the result of extracting a key from a value using a key path with clone and store’s key path. Rethrow any exceptions. ◎ If kpk is invalid, throw a "DataError" DOMException. ◎ If kpk is not failure, let key be kpk. ◎ Otherwise, if the object store does not have a key generator, throw a "DataError" DOMException.

%~target に向けて %~event を配送した上で，真偽値を返す — この~algoの目的においては、 %~event には真偽値をとる `（旧来の）~listenerは投出したか@ が結付けられ，初期~時は ~F をとるとする：

1. `~eventを配送する$( %~target, %~event )
2. ~RET %~event の`（旧来の）~listenerは投出したか$

`~db接続を~openする@ ~algoは、 所与の ( `~storage~key$ %~storage~key, `名前$db %名前 `~version$db %~version `~open要請$ %要請 ) に対し： ◎ To open a database connection with storageKey which requested the database to be opened, a database name, a database version, and a request, run these steps:

1. %~queue ~LET ( %~storage~key, %名前 ) に対する`接続~queue$ ◎ Let queue be the connection queue for storageKey and name.
2. %要請 を %~queue に追加する ◎ Add request to queue.
3. %~queue 内の %要請 以前の要請すべてが処理されるまで待機する ◎ Wait until all previous requests in queue have been processed.
4. %~db ~LET %~storage~key に`専属する$`~db$のうち，次を満たすもの ⇒ `名前$db ~EQ %名前 ◎ Let db be the database named name in storageKey, or null otherwise.
5. ~IF ［ %~version ~EQ ε ］ ⇒ %~version ~SET ［ %~db ~EQ ε ならば 1 ／ ~ELSE_ %~db の`~version$db ］ ◎ If version is undefined, let version be 1 if db is null, or db’s version otherwise.

6. ~IF ［ %~db ~EQ ε ］：

   1. %~db ~LET 次のようにされた，新たな`~db$ ⇒＃ %~storage~key に`専属する$, `名前$db ~SET %名前, `~version$db ~SET `0^c, `専属する$`保管庫$はない
   2. ~IF［ 何らかの事由で前~段は失敗した ］ ⇒ ~RET `Error$( 適切な~error名 ) — 例えば `QuotaExceededError$E ／ `UnknownError$E
   ◎ If db is null, let db be a new database with name name, version 0 (zero), and with no object stores. If this fails for any reason, return an appropriate error (e.g. a "QuotaExceededError" or "UnknownError" DOMException).
7. ~IF［ %~version ~LT %~db の`~version$db ］ ⇒ ~RET `Error$( `VersionError$E ) ◎ If db’s version is greater than version, return a newly created "VersionError" DOMException and abort these steps.
8. %新~接続 ~LET %~db を`~access先$とする新たな`接続$ ◎ Let connection be a new connection to db.
9. %新~接続 の`~version$Cn ~SET %~version ◎ Set connection’s version to version.

10. ~IF ［ %~version ~GT %~db の`~version$db ］： ◎ If db’s version is less than version, then:

    1. %接続~群 ~LET ［ %~db を`~access先$とする`接続$のうち %新~接続 でないもの ］たちが成す`集合$ ◎ Let openConnections be the set of all connections, except connection, associated with db.

    2. %接続~群 を成す ~EACH( %接続 ) に対し ⇒ ~IF［ %接続 の`状態$Cn ~EQ `~open中$i ］ ⇒ 次を走らす`~taskを~queueする$ ⇒ `~version変更~eventを発火する$( %接続, `versionchange$et, %~db の`~version$db, %~version ) ◎ For each entry of openConnections that does not have its close pending flag set to true, queue a task to fire a version change event named versionchange at entry with db’s version and version.

       注記： この~eventの発火は、 上の反復の途中で，いくつかの接続を`~close$させ得る。 それらの接続に向けては、 まだ終えてなくとも `versionchange$et ~eventは発火されない。 ◎ NOTE: Firing this event might cause one or more of the other objects in openConnections to be closed, in which case the versionchange event is not fired at those objects, even if that hasn’t yet been done.

    3. すべての~eventが発火されるまで待機する ◎ Wait for all of the events to be fired.
    4. ~IF［ %接続~群 内に，［ `状態$Cn ~NEQ `~close済み$i ］なる`接続$が依然としてある ］ ⇒ 次を走らす`~taskを~queueする$ ⇒ `~version変更~eventを発火する$( %新~接続, `blocked$et, %~db の`~version$db, %~version ) ◎ If any of the connections in openConnections are still not closed, queue a task to fire a version change event named blocked at request with db’s version and version.
    5. %接続~群 を成す すべての`接続$について，［ その`状態$Cn ~EQ `~close済み$i ］になるまで，待機する ◎ Wait until all connections in openConnections are closed.

    6. `~dbを昇格する$( %新~接続, %~version, %要請 ) ◎ Run upgrade a database using connection, version and request.

       【 `昇格~tx$が`完遂-$するまで待機した上で 】

       • ［ %新~接続 の`状態$Cn ~EQ `~close済み$i ］になったときは ⇒ ~RET `Error$( `AbortError$E ) ◎ If connection was closed, return a newly created "AbortError" DOMException and abort these steps.

       • `昇格~tx$が中止されたときは：

         1. `~db接続を~closeする$( %新~接続 )
         2. ~RET `Error$( `AbortError$E )
         ◎ If the upgrade transaction was aborted, run the steps to close a database connection with connection, return a newly created "AbortError" DOMException and abort these steps.
11. ~RET %新~接続 ◎ Return connection.

`~db接続を~closeする@ ~algoは、 所与の ( `接続$ %接続, %強制するか ~IN { `強制する^i, ε } ) に対し： ◎ To close a database connection with a connection object, and an optional forced flag, run these steps:

1. %接続 の`状態$Cn ~SET `~close待ち$i ◎ Set connection’s close pending flag to true.
2. %~tx群 ~LET ［ %接続 に`専属する$`~tx$であって, `完遂-$していないもの ］たちが成す集合 ◎ ↓
3. ~IF［ %強制するか ~EQ `強制する^i ］ ⇒ %~tx群 を成す ~EACH( `~tx$ %~tx ) に対し ⇒ `~txを中止する$( %~tx, `AbortError$E ) ◎ If the forced flag is true, then for each transaction created using connection run abort a transaction with transaction and newly created "AbortError" DOMException.
4. %~tx群 を成す すべての~txが`完遂-$するまで待機する ◎ Wait for all transactions created using connection to complete.＼
5. %接続 の`状態$Cn ~SET `~close済み$i ◎ Once they are complete, connection is closed.

6. ~IF %強制するか ~EQ `強制する^i ⇒ `~eventを発火する$( %接続, `close$et ) ◎ If the forced flag is true, then fire an event named close at connection.

   注記： `close$et ~eventが発火されるのは、 接続が異常に~closeされた場合に限られる — 例えば： `~storage~key$に対する~storageが~clearされた場合 ／ 破損または入出力~errorがあるとき。 明示的に `close()$m を~callした場合には、 この~eventは`発火されない^em。 ◎ NOTE: The close event only fires if the connection closes abnormally, e.g. if the storage key’s storage is cleared, or there is corruption or an I/O error. If close() is called explicitly the event does not fire.

注記： %接続 の`状態$Cnが `~close待ち$i になって以降は、 %接続 を利用して新たな`~tx$を`作成-$することはできなくなる。 ~txを`作成-$する すべての~methodは、 最初に %接続 の`状態$Cnを検査した上で， `~open中$i でないならば例外を投出する。 ◎ NOTE: Once a connection’s close pending flag has been set to true, no new transactions can be created using the connection. All methods that create transactions first check the connection’s close pending flag first and throw an exception if it is true.

注記： %接続 が `~close済み$i になったなら、［ 所与の`~db$（ %接続 ↗ ）への`接続$たち すべてが~closeされる ］まで`待機して＠#delete-close-block$いた［ `~dbを昇格する$／`~dbを削除する$ ］演算は，`阻まれ＠#version-change-close-block$ないようになり得る。 ◎ NOTE: Once the connection is closed, this can unblock the steps to upgrade a database, and the steps to delete a database, which both wait for connections to a given database to be closed before continuing.

`~dbを削除する@ ~algoは、 所与の ( `~storage~key$ %~storage~key, `名前$db %名前, `~open要請$ %要請 ) に対し： ◎ To delete a database with the storageKey that requested the database to be deleted, a database name, and a request, run these steps:

1. %~queue ~LET ( %~storage~key, %名前 ) に対する`接続~queue$ ◎ Let queue be the connection queue for storageKey and name.
2. %要請 を %~queue に追加する ◎ Add request to queue.
3. %~queue 内の %要請 以前の要請すべてが処理されるまで待機する ◎ Wait until all previous requests in queue have been processed.
4. %~db ~LET %~storage~key に`専属する$`~db$であって, ［ `名前$db ~EQ %名前 ］なるもの ◎ Let db be the database named name in storageKey, if one exists.＼
5. ~IF［ %~db ~EQ ε ］ ⇒ ~RET 0 ◎ Otherwise, return 0 (zero).
6. %接続~群 ~LET ［ %~db を`~access先$とする`接続$ ］のうち［ `状態$Cn ~NEQ `~close済み$i ］を満たすものたちが成す`集合$ ◎ Let openConnections be the set of all connections associated with db.

7. %接続~群 を成す ~EACH( %接続 ) に対し ⇒ ~IF［ %接続 の`状態$Cn ~EQ `~open中$i ］ ⇒ 次を走らす`~taskを~queueする$ ⇒ ~version変更~eventを発火する$( %接続, `versionchange$et, %~db の`~version$db, ~NULL ) ◎ For each entry of openConnections that does not have its close pending flag set to true, queue a task to fire a version change event named versionchange at entry with db’s version and null.

   注記： ここでも，`~dbの~open法と同様の注記＠#_note-open-steps$が該当する。 ◎ NOTE: Firing this event might cause one or more of the other objects in openConnections to be closed, in which case the versionchange event is not fired at those objects, even if that hasn’t yet been done.

8. すべての~eventが発火されるまで待機する ◎ Wait for all of the events to be fired.
9. ~IF［ %接続~群 内に［ `状態$Cn ~NEQ `~close済み$i ］なる`接続$は依然としてある ］ ⇒ 次を走らす`~taskを~queueする$ ⇒ `~version変更~eventを発火する$( %要請, `blocked$et, %~db の`~version$db, ~NULL ) ◎ If any of the connections in openConnections are still not closed, queue a task to fire a version change event named blocked at request with db’s version and null.
10. %接続~群 を成すすべての`接続$について，［ その`状態$Cn ~EQ `~close済み$i ］になるまで，待機する ◎ Wait until all connections in openConnections are closed.
11. %~version ~LET %~db の`~version$db ◎ Let version be db’s version.
12. %~db を削除する ◎ Delete db.＼
13. ~IF［ 何らかの事由で前~段は失敗した ］ ⇒ ~RET `Error$( 適切な~error名 ) — 例えば `QuotaExceededError$E ／ `UnknownError$E ◎ If this fails for any reason, return an appropriate error (e.g. "QuotaExceededError" or "UnknownError" DOMException).
14. ~RET %~version ◎ Return version.

`~txを~commitする@ ~algoは、 所与の ( `~tx$ %~tx ) に対し： ◎ To commit a transaction with the transaction to commit, run these steps:

1. %~tx の`状態$tx ~SET `~commit中$i ◎ Set transaction’s state to committing.

2. この段は`並列的$に走らす： ◎ Run the following steps in parallel:

   1. %~tx の`要請~list$を成す すべての~itemが`処理-済み$になるまで待機する ◎ Wait until every item in transaction’s request list is processed.
   2. ~IF［ %~tx の`状態$tx ~NEQ `~commit中$i ］ ⇒ ~RET ◎ If transaction’s state is no longer committing, then terminate these steps.
   3. %~db ~LET ( %~tx が`専属する$`接続$ )↗ ◎ ↓
   4. %~tx により為された未決な変更のすべてを — %~tx の`耐久能~hint$も考慮する下で — %~db に書込もうと試みる ◎ Attempt to write any outstanding changes made by transaction to the database, considering transaction’s durability hint.

   5. ~IF［ 前~段により書込む間に~errorが生じた ］： ◎ If an error occurs while writing the changes to the database, then＼

      1. `~txを中止する$( %~tx, その~errorに適切な~error名 （例： `QuotaExceededError$E ／ `UnknownError$E ） ) ◎ run abort a transaction with transaction and an appropriate type for the error, for example "QuotaExceededError" or "UnknownError" DOMException,＼
      2. ~RET ◎ and terminate these steps.

   6. 次を走らす`~taskを~queueする$： ◎ Queue a task to run these steps:

      1. ~IF［ %~tx は`昇格~tx$である ］ ⇒ %~db の`昇格~tx$db ~SET ε ◎ If transaction is an upgrade transaction, then set transaction’s connection’s associated database’s upgrade transaction to null.
      2. %~tx の`状態$tx ~SET `完遂d$i ◎ Set transaction’s state to finished.

      3. `~eventを発火する$( %~tx, `complete$et ) ◎ Fire an event named complete at transaction.

         注記： この~event用の~event~handlerから例外が投出されようが、 ~db変更の書込みは~eventを配送する前に終わるので，~txは~commitされる。 `complete$et ~eventが発火されるのは、 ~txが成功裡に書込まれた後に限られる。 ◎ NOTE: Even if an exception is thrown from one of the event handlers of this event, the transaction is still committed since writing the database changes happens before the event takes place. Only after the transaction has been successfully written is the complete event fired.

      4. ~IF［ %~tx は`昇格~tx$である ］ ⇒ ［ %~tx を`設置-先~tx$とする`要請$ 【すなわち、`~dbを昇格する$ときに渡された %要請 】 ］の`設置-先~tx$ ~SET ε ◎ If transaction is an upgrade transaction, then let request be the request associated with transaction and set request’s transaction to null.

【 `~readonly~tx$に対しては、 この手続きは （特に呼出さないようにする要件は見当たらないが） 実質的に何もしない。 】

`~txを中止する@ ~algoは、 所与の ( `~tx$ %~tx, ~error名 %error ) に対し： ◎ To abort a transaction with the transaction to abort, and error, run these steps:

1. %~db ~LET ( %~tx が`専属する$`接続$ )↗ ◎ ↓

2. %~tx により %~db に為された，すべての変更を、 復帰させる — `昇格~tx$に対しては：

   • %~db に`専属する$［ `保管庫$／`索引$ ］たちが成す集合, および`~version$dbの変更も，復帰させる。
   • %~tx の間に作成された［ `保管庫$／`索引$ ］は、 他の~algoの目的においては，削除されたものと見なされる。
   ◎ All the changes made to the database by the transaction are reverted. For upgrade transactions this includes changes to the set of object stores and indexes, as well as the change to the version. Any object stores and indexes which were created during the transaction are now considered deleted for the purposes of other algorithms.

3. ~IF［ %~tx は`昇格~tx$である ］ ⇒ `昇格~txを中止する$( %~tx ) ◎ If transaction is an upgrade transaction, run the steps to abort an upgrade transaction with transaction.

   注記： この結果、［ %~tx が`専属する$`接続$ ／ %~tx に`専属する$［ `保管庫~handle$ ／ `索引~handle$ ］］すべての~instanceに対する変更は復帰されることになる。 ◎ NOTE: This reverts changes to all connection, object store handle, and index handle instances associated with transaction.

4. %~tx の`状態$tx ~SET `完遂d$i ◎ Set transaction’s state to finished.
5. ~IF［ %error ~NEQ ~NULL ］ ⇒ %~tx の`~error$tx ~SET `Error$( %error ) ◎ If error is not null, set transaction’s error to error.

6. %~tx の`要請~list$を成す ~EACH( `要請$ %要請 ) に対し： ◎ For each request of transaction’s request list,＼

   1. %要請 を`非同期に実行する$手続きを中止する ◎ abort the steps to asynchronously execute a request for request,＼
   2. %要請 の`処理-済みか$ ~SET ~T ◎ set request’s processed flag to true,＼

   3. 次を走らす`~taskを~queueする$： ◎ and queue a task to run these steps:

      1. %要請 の ⇒＃ `済んだか$ ~SET ~T, `結果$ ~SET ε, `~error$ ~SET `Error$( `AbortError$E ) ◎ Set request’s done flag to true. ◎ Set request’s result to undefined. ◎ Set request’s error to a newly created "AbortError" DOMException.
      2. `~eventを発火する$( %要請, `error$et ) — 次のように初期化して ⇒＃ `bubbles$m 属性 ~SET ~T, `cancelable$m 属性 ~SET ~T ◎ Fire an event named error at request with its bubbles and cancelable attributes initialized to true.

      注記： これは常に `error$et ~eventを発火させるとは限らない。 例えば~txが `~commit中$i の間に~errorに因り中止された場合や，それは失敗した最後の残りの要請であった場合 【？】。 ◎ NOTE: This does not always result in any error events being fired. For example if a transaction is aborted due to an error while committing the transaction, or if it was the last remaining request that failed.

7. 次を走らす`~taskを~queueする$： ◎ Queue a task to run these steps:

   1. ~IF［ %~tx は`昇格~tx$である ］ ⇒ %~db の`昇格~tx$db ~SET ε ◎ If transaction is an upgrade transaction, then set transaction’s connection’s associated database’s upgrade transaction to null.
   2. `~eventを発火する$( %~tx, `abort$et ) — 次のように初期化して ⇒ `bubbles$m 属性 ~SET ~T ◎ Fire an event named abort at transaction with its bubbles attribute initialized to true.

   3. ~IF［ %~tx は`昇格~tx$である ］： ◎ If transaction is an upgrade transaction, then:

      1. %要請 ~LET %~tx を`設置-先~tx$とする`~open要請$ 【すなわち、`~dbを昇格する$ときに渡された %要請 】 ◎ Let request be the open request associated with transaction.
      2. %要請 の ⇒＃ `設置-先~tx$ ~SET ε, `結果$ ~SET ε, `処理-済みか$ ~SET ~F, `済んだか$ ~SET ~F ◎ Set request’s transaction to null. ◎ Set request’s result to undefined. ◎ Set request’s processed flag to false. ◎ Set request’s done flag to false.

1. %~tx ~LET %~source が`専属する$`~tx$ ◎ Let transaction be the transaction associated with source.
2. ~Assert： %~tx の`状態$tx ~EQ `作動中$i ◎ Assert: transaction’s state is active.
3. ~IF［ %要請 ~EQ ε ］ ⇒ %要請 ~SET `要請$を表現する，新たな `IDBRequest$I ~obj — その ⇒＃ `~source$ ~SET %~source, `設置-先~tx$ ~SET %~tx ◎ If request was not given, let request be a new request with source as source.
4. %~tx の`要請~list$に %要請 を追加する ◎ Add request to the end of transaction’s request list.
5. ~RET %要請 — ただし，以降も`並列的$に走らす ◎ Run these steps in parallel:
6. 次が満たされるまで待機する ⇒ %要請 は［ %~tx の`要請~list$を成す`処理-済み$でない~item ］のうち最初のものである ◎ Wait until request is the first item in transaction’s request list that is not processed.
7. %結果 ~LET %演算 を遂行した結果 ◎ Let result be the result of performing operation.
8. ~IF［ %結果 は~errorである ］~AND［ %~tx の`状態$tx ~EQ `~commit中$i ］ ⇒＃ `~txを中止する$( %~tx, %結果 )； ~RET ◎ If result is an error and transaction’s state is committing, then run abort a transaction with transaction and result, and terminate these steps.

9. ~IF［ %結果 は~errorである ］ ⇒ %演算 により生じたすべての変更を復帰する ◎ If result is an error, then revert all changes made by operation.

   注記： これは、 この要請により行われた変更のみを復帰させる。 ~txにより為された他の変更は復帰されない。 ◎ NOTE: This only reverts the changes done by this request, not any other changes made by the transaction.

10. %要請 の`処理-済みか$ ~SET ~T ◎ Set request’s processed flag to true.

11. 次を走らす`~taskを~queueする$： ◎ Queue a task to run these steps:

    1. %~tx の`要請~list$から %要請 を除去する ◎ Remove request from transaction’s request list.

    2. %要請 の ⇒＃ `済んだか$ ~SET ~T, `結果$ ~SET ε, `~error$ ~SET ε ◎ Set request’s done flag to true. ◎ ↓

    3. ~IF［ %結果 は~errorである ］： ◎ If result is an error, then:

       1. %要請 の`~error$ ~SET %結果 ◎ Set request’s result to undefined. ◎ Set request’s error to result.
       2. `~error~eventを発火する$( %要請 ) ◎ Fire an error event at request.

    4. ~ELSE： ◎ Otherwise:

       1. %要請 の`結果$ ~SET %結果 ◎ Set request’s result to result. ◎ Set request’s error to undefined.
       2. `~success~eventを発火する$( %要請 ) ◎ Fire a success event at request.

`~dbを昇格する@ ~algoは、 所与の ( `接続$ %接続, %~version `要請$ %要請 ) に対し： ◎ To upgrade a database with connection (a connection), a new version, and a request, run these steps:

1. %~db ~LET %接続↗ ◎ Let db be connection’s database.
2. %~tx ~LET 新たな`昇格~tx$ — その ⇒＃ `専属する$`接続$ ~SET %接続, `視野$ ~SET %接続 の`保管庫~集合$Cn ◎ Let transaction be a new upgrade transaction with connection used as connection. ◎ Set transaction’s scope to connection’s object store set.
3. %~db の`昇格~tx$db ~SET %~tx ◎ Set db’s upgrade transaction to transaction.
4. %~tx の`状態$tx ~SET `非作動中$i ◎ Set transaction’s state to inactive.

5. %~tx を開始する ◎ Start transaction.

   注記： この`~tx$が`完遂-$するまで，他の`接続$は %~db を~openできないことに注意。 ◎ NOTE: Note that until this transaction is finished, no other connections can be opened to the same database.

6. %旧~version ~LET %~db の`~version$db ◎ Let old version be db’s version.
7. %~db の`~version$db ~SET %~version — この変更は，`~tx$の一部と見なされ、 ~txが`中止-$された場合には復帰される。 ◎ Set db’s version to version. This change is considered part of the transaction, and so if the transaction is aborted, this change is reverted.
8. %要請 の`処理-済みか$ ~SET ~T ◎ Set request’s processed flag to true.

9. 次を走らす`~taskを~queueする$： ◎ Queue a task to run these steps:

   1. %要請 の`結果$ ~SET %接続 ◎ Set request’s result to connection.
   2. %要請 の`設置-先~tx$ ~SET %~tx ◎ Set request’s transaction to transaction.
   3. %要請 の`済んだか$ ~SET ~T ◎ Set request’s done flag to true.
   4. %~tx の`状態$tx ~SET `作動中$i ◎ Set transaction’s state to active.
   5. %~listenerは投出したか ~LET `~version変更~eventを発火する$( %要請, `upgradeneeded$et, %旧~version, %~version ) ◎ Let didThrow be the result of firing a version change event named upgradeneeded at request with old version and version.
   6. %~tx の`状態$tx ~SET `非作動中$i ◎ Set transaction’s state to inactive.
   7. ~IF［ %~listenerは投出したか ~EQ ~T ］ ⇒ `~txを中止する$( %~tx, `AbortError$E ) ◎ If didThrow is true, run abort a transaction with transaction and a newly created "AbortError" DOMException.

10. %~tx が`完遂-$するまで待機する ◎ Wait for transaction to finish.

    注記： ［ `~txを~commitする$／ `~txを中止する$ ］手続きなど，~txの存続期間に呼出される一部の~algoは、 `昇格~tx$に特有な手続きを含む。 ◎ NOTE: Some of the algorithms invoked during the transaction’s lifetime, such as the steps to commit a transaction and the steps to abort a transaction, include steps specific to upgrade transactions.

`昇格~txを中止する@ ~algoは、 所与の ( `昇格~tx$ %~tx ) に対し： ◎ To abort an upgrade transaction with transaction, run these steps:

注記： この手続きは，`~txを中止-$する手続き内で必要に応じて走らされ、 `~db$に`専属する$［ `保管庫$／`索引$ ］たちが成す集合, および `~version$db変更を復帰させる。 【~APIに公開される部分を復帰させる。】 ◎ NOTE: These steps are run as needed by the steps to abort a transaction, which revert changes to the database including the set of associated object stores and indexes, as well as the change to the version.

1. %接続 ~LET %~tx が`専属する$`接続$ ◎ Let connection be transaction’s connection.
2. %~db ~LET %接続↗ ◎ Let database be connection’s database.

3. %接続 の`~version$Cn ~SET %~db の`~version$db （ %~tx が %~db を新たに作成したのであれば 0 ） ◎ Set connection’s version to database’s version if database previously existed, or 0 (zero) if database was newly created.

   注記： これは、 `IDBDatabase!I ~objから返される `version$m 値を復帰させる。 ◎ NOTE: This reverts the value of version returned by the IDBDatabase object.

4. %接続 の`保管庫~集合$Cn ~SET %~db に`専属する$`保管庫$たちが成す集合 （ %~tx が %~db を新たに作成したのであれば 空~集合 ） ◎ Set connection’s object store set to the set of object stores in database if database previously existed, or the empty set if database was newly created.

   注記： これは、 `IDBDatabase!I ~objから返される `objectStoreNames$m 値を復帰させる。 ◎ NOTE: This reverts the value of objectStoreNames returned by the IDBDatabase object.

5. この段において反復される~handleたちには、 その`~access先$が %~tx により削除-または作成されたものも含まれることに注意。 ◎ ↓

   %~tx に`専属する$ ~EACH( `保管庫~handle$ %H ) に対し： ◎ For each object store handle handle associated with transaction, including those for object stores that were created or deleted during transaction:

   1. ~IF［ %H↗ は %~tx により作成されたものではない ］ ⇒ %H の`名前$OsH ~SET %H↗ の`名前$Os ◎ If handle’s object store was not newly created during transaction, set handle’s name to its object store’s name.

   2. %H の`索引~集合$OsH ~SET %H↗ に`専属する$`索引$たちが成す集合 ◎ Set handle’s index set to the set of indexes that reference its object store.

      注記： これは、 %H （を表現する `IDBObjectStore!I ~obj）が返す［ `name$m, `indexNames$m ］値を復帰させる。 ◎ NOTE: This reverts the values of name and indexNames returned by related IDBObjectStore objects.

      ~scriptは、 %~tx が中止されて以降も，依然として自身が有する %H の［ `name$m ／ `indexNames$m ］属性は~queryできる — %~tx の `objectStore()$m ~methodを利用しても， %H↗ には~accessできなくなるが。 ◎ How is this observable? ◎ Although script cannot access an object store by using the objectStore() method on an IDBTransaction instance after the transaction is aborted, it can still have references to IDBObjectStore instances where the name and indexNames properties can be queried.

   3. %H に`専属する$ ~EACH( `索引~handle$ %I ) に対し： ◎ For each index handle handle associated with transaction, including those for indexes that were created or deleted during transaction:

      1. ~IF［ %I↗ は %~tx により作成されたものではない ］ ⇒ %I の`名前$IxH ~SET %I↗ の`名前$Ix ◎ If handle’s index was not newly created during transaction, set handle’s name to its index’s name.

      注記： これは、 %I （を表現する `IDBIndex!I ~obj）が返す `name$m 値を復帰させる。 ◎ NOTE: This reverts the value of name returned by related IDBIndex objects.

      ~scriptは、 %~tx が中止されて以降も，自身が有する %I の `name$m 属性は~queryできる — %H の `index()$m ~methodを利用しても， %I↗ には~accessできなくなるが。 ◎ How is this observable? ◎ Although script cannot access an index by using the index() method on an IDBObjectStore instance after the transaction is aborted, it can still have references to IDBIndex instances where the name property can be queried.

`~success~eventを発火する@ ~algoは、 所与の ( `要請$ %要請 ) に対し： ◎ To fire a success event at a request, run these steps:

1. %~event ~LET `~eventを作成する$( `Event$I ) ◎ Let event be the result of creating an event using Event.
2. %~event の各種~属性を次のように初期化する ⇒＃ `type$m ~SET `success^l, `bubbles$m ~SET ~F, `cancelable$m ~SET ~F ◎ • Set event’s type attribute to "success". • Set event’s bubbles and cancelable attributes to false.
3. %~tx ~LET %要請 の`設置-先~tx$ ◎ Let transaction be request’s transaction. ◎ ↓Let legacyOutputDidListenersThrowFlag be initially false.
4. ~IF［ %~tx の`状態$tx ~EQ `非作動中$i ］ ⇒ %~tx の`状態$tx ~SET `作動中$i ◎ If transaction’s state is inactive, then set transaction’s state to active.
5. %~listenerは投出したか ~LET `Dispatch$( %要請, %~event ) ◎ Dispatch event at request with legacyOutputDidListenersThrowFlag.
6. ~IF［ %~tx の`状態$tx ~NEQ `作動中$i ］ ⇒ ~RET ◎ If transaction’s state is active, then:
7. %~tx の`状態$tx ~SET `非作動中$i ◎ Set transaction’s state to inactive.
8. ~IF［ %~listenerは投出したか ~EQ ~T ］ ⇒ `~txを中止する$( %~tx, `AbortError$E ) ◎ If legacyOutputDidListenersThrowFlag is true, then run abort a transaction with transaction and a newly created "AbortError" DOMException.
9. ~IF［ %~tx の`要請~list$は空である ］ ⇒ `~txを~commitする$( %~tx ) ◎ If transaction’s request list is empty, then run commit a transaction with transaction.

`~error~eventを発火する@ ~algoは、 所与の ( `要請$ %要請 ) に対し： ◎ To fire an error event at a request, run these steps:

1. %~event ~LET `~eventを作成する$( `Event$I ) ◎ Let event be the result of creating an event using Event.
2. %~event の各種~属性を次のように初期化する ⇒＃ `type$m ~SET `error^l, `bubbles$m ~SET ~T, `cancelable$m ~SET ~T ◎ • Set event’s type attribute to "error". • Set event’s bubbles and cancelable attributes to true.
3. %~tx ~LET %要請 の`設置-先~tx$ ◎ Let transaction be request’s transaction. ◎ ↓Let legacyOutputDidListenersThrowFlag be initially false.
4. ~IF［ %~tx の`状態$tx ~EQ `非作動中$i ］ ⇒ %~tx の`状態$tx ~SET `作動中$i ◎ If transaction’s state is inactive, then set transaction’s state to active.
5. %~listenerは投出したか ~LET `Dispatch$( %要請, %~event ) ◎ Dispatch event at request with legacyOutputDidListenersThrowFlag.
6. ~IF［ %~tx の`状態$tx ~NEQ `作動中$i ］ ⇒ ~RET ◎ If transaction’s state is active, then:
7. %~tx の`状態$tx ~SET `非作動中$i ◎ Set transaction’s state to inactive.

8. ~IF［ %~listenerは投出したか ~EQ ~T ］： ◎ If legacyOutputDidListenersThrowFlag is true, then＼

   1. `~txを中止する$( %~tx, `AbortError$E ) ◎ run abort a transaction with transaction and a newly created "AbortError" DOMException and＼
   2. ~RET ◎ terminate these steps.＼

   この段は、［ %~event の`取消されたか$ev ~EQ ~F ］の下でも行われる。 ◎ This is done even if event’s canceled flag is false.

   注記： すなわち、 `error$et ~eventの配送-時に，いずれかの~event~handlerから例外が投出されたときは：

   • ~eventが `preventDefault()$m の~callにより取消されようが されまいが，~txは中止される。
   • ~tx上の `error^m 属性には、 要請の`~error$に代わって， `AbortError$E が利用される。

   ◎ NOTE: This means that if an error event is fired and any of the event handlers throw an exception, transaction’s error property is set to an AbortError rather than request’s error, even if preventDefault() is never called.
9. ~IF［ %~event の`取消されたか$ev ~EQ ~F ］ ⇒＃ `~txを中止する$( %~tx, %要請 の`~error$ )； ~RET ◎ If event’s canceled flag is false, then run abort a transaction using transaction and request’s error, and terminate these steps.
10. ~IF［ %~tx の`要請~list$は空である ］ ⇒ `~txを~commitする$( %~tx ) ◎ If transaction’s request list is empty, then run commit a transaction with transaction.

`~txの間に値を~cloneする@ ~algoは、 所与の ( %値, `~tx$ %~tx ) に対し： ◎ To make a clone of value in targetRealm during transaction, run these steps:

注記： 値を複製するわけは： 値は格納-時に【 `StructuredSerializeForStorage$jA により】直列化されるが，この手続きを用いて複製として扱うことにより、 この仕様~内の他の~algoは，それを~ES値として扱えるようになる。 実装は、 異なる挙動が観測され得ないならば，これを最適化できる。 【！ https://github.com/w3c/IndexedDB/commit/4ccf4371e3e1a32a6f3ab1606605e71a8f4f8334】

1. %宛先~realm ~LET ~UAにより定義される`~realm$ 【この訳では、この手続きを利用している各所の記述を集約するため，この段と上の注記をここに追加している。】
2. ~Assert： %~tx の`状態$tx ~EQ `作動中$i ◎ Assert: transaction’s state is active.

3. %~tx の`状態$tx ~SET `非作動中$i ◎ Set transaction’s state to inactive.

   注記： %~tx を `非作動中$i にするのは、 ~cloneする演算により誘発される取得子その他の副作用が， %~tx に対し追加の要請を為せないようにするためである。 ◎ NOTE: The transaction is made inactive so that getters or other side effects triggered by the cloning operation are unable to make additional requests against the transaction.

4. %直列形 ~LET ~ABRUPT `StructuredSerializeForStorage$jA( %値 ) ◎ Let serialized be ? StructuredSerializeForStorage(value).
5. %~clone ~LET ~ABRUPT `StructuredDeserialize$jA( %直列形, %宛先~realm ) ◎ Let clone be ? StructuredDeserialize(serialized, targetRealm).
6. %~tx の`状態$tx ~SET `作動中$i ◎ Set transaction’s state to active.
7. ~RET %~clone ◎ Return clone.

`保管庫に~recordを格納する@ ~algoは、 所与の ( `保管庫$ %保管庫, `値$ %値, `~key$ %~key（省略時は ε ）, %上書不可か ~IN { `上書不可^i, ε } ) に対し： ◎ To store a record into an object store with store, value, an optional key, and a no-overwrite flag, run these steps:

1. %生成器 ~LET %保管庫 の`~key生成器$ ◎ ↓
2. %~key~path ~LET %保管庫 の`~key~path$Os ◎ ↓

3. ~IF［ %生成器 ~NEQ ε ］： ◎ If store uses a key generator, then:

   1. ~IF［ %~key ~EQ ε ］： ◎ If key is undefined, then:

      1. %~key ~LET `保管庫~用の~keyを生成する$( %保管庫 ) ◎ Let key be the result of generating a key for store.
      2. ~IF［ %~key ~EQ `失敗^i ］ ⇒ ~RET `Error$( `ConstraintError$E ) ◎ If key is failure, then this operation failed with a "ConstraintError" DOMException. Abort this algorithm without taking any further steps.
      3. ~IF［ %~key~path ~NEQ ε ］ ⇒ `~keyを値の中へ注入する$( %値, %~key, %保管庫 の`~key~path$Os ) ◎ If store also uses in-line keys, then run inject a key into a value using a key path with value, key and store’s key path.
   2. ~ELSE ⇒ `保管庫~用の~key生成器を可能なら更新する$( %保管庫, %~key ) ◎ Otherwise, run possibly update the key generator for store with key.

4. ~IF［ %保管庫 の`~record~list$Os内に［ `~key$ ~EQ~cmpkey %~key ］を満たす`~record$は在る ］ ◎ ↓

   1. ~IF［ %上書不可か ~EQ `上書不可^i ］ ⇒ ~RET `Error$( `ConstraintError$E ) ◎ If the no-overwrite flag was given to these steps and is true, and a record already exists in store with its key equal to key, then this operation failed with a "ConstraintError" DOMException. Abort this algorithm without taking any further steps.
   2. `保管庫から~recordを削除する$( %保管庫, `Only$( %~key ) ) ◎ If a record already exists in store with its key equal to key, then remove the record from store using delete records from an object store.
5. %保管庫 の`~record~list$Osに ~record｛ %~key ： ~NOABRUPT `StructuredSerializeForStorage$jA( %値 ) ｝ を格納する — それに伴い，~listの~recordたちを~keyの`昇順$で~sortし直すことになる。 ◎ Store a record in store containing key as its key and ! StructuredSerializeForStorage(value) as its value. The record is stored in the object store’s list of records such that the list is sorted according to the key of the records in ascending order.

6. %保管庫 に`専属する$ ~EACH( `索引$ %索引 ) に対し： ◎ For each index which references store:

   1. %~key集合 ~LET `値から~key集合を抽出する$( %値, %索引 の`~key~path$Ix, %索引 の`複-~entryか$Ix ) ◎ Let index key be the result of extracting a key from a value using a key path with value, index’s key path, and index’s multiEntry flag.
   2. ~IF［ %~key集合 ~EQ `失敗^i ］ ⇒ ~CONTINUE ◎ If index key is an exception, or invalid, or failure, take no further actions for index, and continue these steps for the next index. ◎ NOTE: An exception thrown in this step is not rethrown.

   3. ~IF［ %索引 の`一意か$Ix ~EQ ~T ］~AND［ %索引 の`~record~list$Ix内に［ `~key$ ~IN~cmpkey %~key集合 ］を満たす`~record$は在る ］ ⇒ ~RET `Error$( `ConstraintError$E ) ◎ If index’s multiEntry flag is false, or if index key is not an array key, and if index already contains a record with key equal to index key, and index’s unique flag is true, then this operation failed with a "ConstraintError" DOMException. Abort this algorithm without taking any further steps. ◎ If index’s multiEntry flag is true and index key is an array key, and if index already contains a record with key equal to any of the subkeys of index key, and index’s unique flag is true, then this operation failed with a "ConstraintError" DOMException. Abort this algorithm without taking any further steps.

      【 この手続きを呼び出した要請は失敗とされ、 `要請を非同期に実行する$手続きに従って，ここまでの改変は復帰されることになる。 したがって、 索引たちを反復する順序も，結果には影響しない。 】

   4. %~key集合 を成す ~EACH( %索引~key ) に対し ⇒ %索引 の`~record~list$Ix内に 新たな~record｛ %索引~key ： %~key ｝ を格納する — それに伴い、 ~record~listは 先ず~keyの`昇順$に~sortした上で，~keyが等しい~recordたちを値の`昇順$に~sortすることになる。 ◎ If index’s multiEntry flag is false, or if index key is not an array key then store a record in index containing index key as its key and key as its value. The record is stored in index’s list of records such that the list is sorted primarily on the records keys, and secondarily on the records values, in ascending order. ◎ If index’s multiEntry flag is true and index key is an array key, then for each subkey of the subkeys of index key store a record in index containing subkey as its key and key as its value. The records are stored in index’s list of records such that the list is sorted primarily on the records keys, and secondarily on the records values, in ascending order.

      注記： %~key集合 が空でも妥当である — その場合、 索引に追加される~recordはない。 ◎ NOTE: It is valid for there to be no subkeys. In this case no records are added to the index. ◎ NOTE: Even if any member of subkeys is itself an array key, the member is used directly as the key for the index record. Nested array keys are not flattened or "unpacked" to produce multiple rows; only the outer-most array key is.

   【この段の訳は、再構成により，原文より簡素化している（`値から~key集合を抽出する$を見よ）。】
7. ~RET %~key ◎ Return key.

`保管庫から~recordを削除する@ ~algoは、 所与の ( `保管庫$ %保管庫, `~key範囲$ %範囲 ) に対し： ◎ To delete records from an object store with store and range, run these steps:

1. %保管庫 の`~record~list$Osから，次を満たす`~record$をすべて除去する ⇒ `~key$ ~IN~cmpkey %範囲 ◎ Remove all records, if any, from store’s list of records with key in range.
2. %保管庫 に`専属する$ ~EACH( `索引$ ) に対し ⇒ `索引$の`~record~list$Ixから，次を満たす`~record$をすべて除去する ⇒ `値$ ~IN~cmpkey %範囲 ◎ For each index which references store, remove every record from index’s list of records whose value is in range, if any such records exist.
3. ~RET ε ◎ Return undefined.

`範囲に入る~recordを数える@ ~algoは、 所与の ( `保管庫$または`索引$ %~source, `~key範囲$ %範囲 ) に対し： ◎ To count the records in a range with source and range, run these steps:

1. ~RET %~source の~record~list内の，次を満たす`~record$の総数 ⇒ `~key$ ~IN~cmpkey %範囲 ◎ Let count be the number of records, if any, in source’s list of records with key in range. ◎ Return count.

`保管庫を~clearする@ ~algoは、 所与の ( `保管庫$ %保管庫 ) に対し： ◎ To clear an object store with store, run these steps:

1. %保管庫 からすべての`~record$を除去する ◎ Remove all records from store.
2. %保管庫 に`専属する$ ~EACH( `索引$ ) に対し ⇒ `索引$からすべての`~record$を除去する ◎ In all indexes which reference store, remove all records.
3. ~RET ε ◎ Return undefined.

`~cursorを作成する@ ~algoは、 所与の ⇒＃ %~source ： `保管庫~handle$／`索引~handle$, %宛先~realm ：`~realm$, %方向 ： `方向$Cs, %範囲： `~key範囲$, %~keyのみ~flag ~IN { `~keyのみ^i, ε }（省略時は ε ） ◎終 に対し：

1. %~keyのみか ~LET ~IS［ %~keyのみ~flag ~EQ `~keyのみ^i ］
2. %~interface ~LET %~keyのみか に応じて ⇒＃ ~T ならば `IDBCursor!I ／ ~F ならば `IDBCursorWithValue!I
3. %~cursor ~LET %宛先~realm 内で %~interface を実装する新たな`~cursor$
4. %~cursor の ⇒＃ `~source$Cs ~SET %~source, `範囲$Cs ~SET %範囲, `方向$Cs ~SET %方向, `位置$Cs ~SET ε, `保管庫~位置$Cs ~SET ε, `~key$Cs ~SET ε, `値$Cs ~SET ε, `値は取得-済みか$Cs ~SET ~F, `~keyのみか$Cs ~SET %~keyのみか
5. ~RET `~cursorを反復する$( %~cursor, %宛先~realm )

`~cursorを反復する@ ~algoは、 所与の ⇒＃ %~cursor： `~cursor$, %宛先~realm：`~realm$, %~key ： 移動先の`~key$（省略時は ε ）, %首key ： 保管庫における移動先の`~key$（省略時は ε ）, %count ： 反復する回数（省略時は ε ） ◎終 に対し： ◎ To iterate a cursor with targetRealm, cursor, an optional key and primaryKey to iterate to, and an optional count, run these steps:

1. %~source ~LET %~cursor の`~source$Cs↗ ◎ Let source be cursor’s source.
2. %方向 ~LET %~cursor の`方向$Cs ◎ Let direction be cursor’s direction.
3. ~Assert： ［ %首key ~EQ ε ］~OR［［ %~source は`索引$である ］~AND［ %方向 ~IN { `next^l, `prev^l } ］］ ◎ Assert: if primaryKey is given, source is an index and direction is "next" or "prev".

4. %~record~list ~LET %~source 内の すべての~recordからなる~list ◎ Let records be the list of records in source.

   注記： %~record~list は常に`~key$の昇順で~sortされる。 %~source が`索引$である場合、 それに加えて，同じ`~key$を有する~recordたちは，それらの`値$ （すなわち， ~recordの`参照先~record$の`~key$） の`昇順$でも~sortされる。 ◎ NOTE: records is always sorted in ascending key order. In the case of source being an index, records is secondarily sorted in ascending value order (where the value in an index is the key of the record in the referenced object store).

5. %範囲 ~LET %~cursor の`範囲$Cs ◎ Let range be cursor’s range.
6. %位置 ~LET %~cursor の`位置$Cs ◎ Let position be cursor’s position.
7. %保管庫~位置 ~LET %~cursor の`保管庫~位置$Cs ◎ Let object store position be cursor’s object store position.
8. ~IF［ %count ~EQ ε ］ ⇒ %count ~SET 1 ◎ If count is not given, let count be 1.

9. %~record ~LET 次の手続きを走らせた結果 （これは、 %~record~list から一つの~recordに絞り込む）：

   1. %~record~list から［ `~key$ ~NIN~cmpkey %範囲 ］を満たす~recordすべてを除去する
   2. ~IF［ %位置 ~NEQ ε ］：

      1. ~IF［ %~source は`保管庫$である ］~OR［ %方向 ~IN { `nextunique$l, `prevunique$l } ］ ⇒ %~record~list から［ %方向 に応じて，次に与える条件 ］を満たす~recordすべてを除去する：

         `next$l

         `nextunique$l

         `~key$ ~LTE~cmpkey %位置

         `prev$l

         `prevunique$l

         `~key$ ~GTE~cmpkey %位置

      2. ~ELSE ⇒ %~record~list から［ %方向 に応じて，次に与える条件 ］を満たす~recordすべてを除去する：

         `next$l

         ( `~key$, `値$ ) ~LTE~cmpkey ( %位置, %保管庫~位置 )

         `prev$l

         ( `~key$, `値$ ) ~GTE~cmpkey ( %位置, %保管庫~位置 )

      3. ~IF［ %~key ~NEQ ε ］

         1. ~IF［ %首key ~EQ ε ］ ⇒ %~record~list から［ %方向 に応じて，次に与える条件 ］を満たす~recordすべてを除去する：

            `next$l

            `nextunique$l

            `~key$ ~LT~cmpkey %~key

            `prev$l

            `prevunique$l

            `~key$ ~GT~cmpkey %~key

         2. ~ELSE ⇒ %~record~list から［ %方向 に応じて，次に与える条件 ］を満たす~recordすべてを除去する：

            `next$l

            ( `~key$, `値$ ) ~LT~cmpkey ( %~key, %首key )

            `prev$l

            ( `~key$, `値$ ) ~GT~cmpkey ( %~key, %首key )

   3. ~IF［ %方向 ~IN { `nextunique$l, `prevunique$l } ］ ⇒ %~record~list を成す ~EACH( ~keyが互いに`等しい$一群の~record ) に対し ⇒ それらのうち，最初のもの以外の~recordすべてを %~record~list から除去する 【！Iterating with "prevunique" visits the same records that "nextunique" visits, but in reverse order.】
   4. ~IF［ %~record~list を成す~recordの個数 ~GTE %count ］ ⇒ ~RET ε

   5. ~RET %方向 に応じて，次に与える~record：

      `next$l

      `nextunique$l

      %~record~list 内の最初から %count 個目の~record

      `prev$l

      `prevunique$l

      %~record~list 内の最後から %count 個目の~record

   While count is greater than 0:

   1. Switch on direction:

      "next"

      Let found record be the first record in records which satisfy all of the following requirements:

      • If key is defined, the record’s key is greater than or equal to key.
      • If primaryKey is defined, the record’s key is equal to key and the record’s value is greater than or equal to primaryKey, or the record’s key is greater than key.
      • If position is defined, and source is an object store, the record’s key is greater than position.
      • If position is defined, and source is an index, the record’s key is equal to position and the record’s value is greater than object store position or the record’s key is greater than position.
      • The record’s key is in range.

      "nextunique"

      ◎ Let found record be the first record in records which satisfy all of the following requirements:

      • If key is defined, the record’s key is greater than or equal to key.
      • If position is defined, the record’s key is greater than position.
      • The record’s key is in range.

      "prev"

      Let found record be the last record in records which satisfy all of the following requirements:

      • If key is defined, the record’s key is less than or equal to key.
      • If primaryKey is defined, the record’s key is equal to key and the record’s value is less than or equal to primaryKey, or the record’s key is less than key.
      • If position is defined, and source is an object store, the record’s key is less than position.
      • If position is defined, and source is an index, the record’s key is equal to position and the record’s value is less than object store position or the record’s key is less than position.
      • The record’s key is in range.

      "prevunique"

      Let temp record be the last record in records which satisfy all of the following requirements:

      • If key is defined, the record’s key is less than or equal to key.
      • If position is defined, the record’s key is less than position.
      • The record’s key is in range.

      If temp record is defined, let found record be the first record in records whose key is equal to temp record’s key.

      NOTE: Iterating with "prevunique" visits the same records that "nextunique" visits, but in reverse order.

   2. ↓↓ If found record is not defined, then:

      1. Set cursor’s key to undefined.
      2. If source is an index, set cursor’s object store position to undefined.
      3. If cursor’s key only flag is false, set cursor’s value to undefined.
      4. Return null.
   3. Let position be found record’s key.
   4. If source is an index, let object store position be found record’s value.
   5. Decrease count by 1.

10. ~IF［ %~record ~EQ ε ］：

    1. %~cursor の`~key$Cs ~SET ε
    2. ~IF［ %~source は`索引$である ］ ⇒ %~cursor の`保管庫~位置$Cs ~SET ε
    3. ~IF［ %~cursor の`~keyのみか$Cs ~EQ ~F ］ ⇒ %~cursor の`値$Cs ~SET ε
    4. ~RET ~NULL
    ◎ ↑
11. %~cursor の`位置$Cs ~SET %~record の`~key$ ◎ Set cursor’s position to position.
12. ~IF［ %~source は`索引$である ］ ⇒ %~cursor の`保管庫~位置$Cs ~SET %~record の`値$ ◎ If source is an index, set cursor’s object store position to object store position.
13. %~cursor の`~key$Cs ~SET %~record の`~key$ ◎ Set cursor’s key to found record’s key.

14. ~IF［ %~cursor の`~keyのみか$Cs ~EQ ~F ］： ◎ If cursor’s key only flag is false, then:

    1. ~IF［ %~source は`索引$である ］ ⇒ %直列形 ~LET %~record の`参照先~record$の`値$ ◎ Let serialized be found record’s referenced value.
    2. %~cursor の`値$Cs ~SET ~NOABRUPT `StructuredDeserialize$jA( %直列形, %宛先~realm ) ◎ Set cursor’s value to ! StructuredDeserialize(serialized, targetRealm)
15. %~cursor の`値は取得-済みか$Cs ~SET ~T ◎ Set cursor’s got value flag to true.
16. ~RET %~cursor ◎ Return cursor.

`~key~pathを評価する@ ~algoは、 所与の ( `値$ %値, `~key~path$ %~key~path ) に対し，［ ~ES値／`失敗^i ］を返すか例外を投出する： ◎ To evaluate a key path on a value with value and keyPath, run the following steps. The result of these steps is an ECMAScript value or failure, or the steps may throw an exception.

【 返り値 `失敗^i は、 %値 の中に %~key~path が指す部位が無いことを表す。 】

1. ~IF［ %~key~path は文字列たちが成す`~list$である ］： ◎ If keyPath is a list of strings, then:

   1. %結果 ~LET 式 `[]^jv で作成されるものと同じ，新たな `Array$jT ~obj ◎ Let result be a new Array object created as if by the expression [].
   2. %i ~LET 0 ◎ Let i be 0.

   3. %~key~path を成す ~EACH( %item ) に対し： ◎ For each item of keyPath:

      1. %~key ~LET ~NOABRUPT `~key~pathを評価する$( %値, %item ) † 【！原文は引数順序が逆】 ◎ Let key be the result of recursively evaluating a key path on a value with item and value. ◎ Assert: key is not an abrupt completion.
      2. ~IF［ %~key ~EQ `失敗^i ］ ⇒ ~RET `失敗^i ◎ If key is failure, abort the overall algorithm and return failure.
      3. %p ~LET ~NOABRUPT `ToString$jA( %i ) ◎ Let p be ! ToString(i).
      4. %状態s ~LET `CreateDataProperty$jA( %result, %p, %~key ) ◎ Let status be CreateDataProperty(result, p, key).
      5. ~Assert： %状態s ~EQ ~T ◎ Assert: status is true.
      6. %i ~INCBY 1 ◎ Increase i by 1.
   4. ~RET %結果 ◎ Return result.

   注記（†）： これは、 一階層のみ “再帰する” — `~key~path$ 連列は入子にできないので。 ◎ NOTE: This will only ever "recurse" one level since key path sequences can’t ever be nested.

2. ~IF［ %~key~path ~EQ 空~文字列 ］ ⇒ ~RET %値 【！ この段は不要 】 ◎ If keyPath is the empty string, return value and skip the remaining steps.
3. %識別子~list ~LET `区切子で厳密に分割する$( %~key~path, `002E^U (`.^l) ) ◎ Let identifiers be the result of strictly splitting keyPath on U+002E FULL STOP characters (.).

4. %識別子~list を成す ~EACH( %識別子 ) に対し ◎ For each identifier of identifiers, jump to the appropriate step below:

   1. ~IF［ 下の表t内に ( %値 が満たす条件, %識別子 ) に該当する行は在る ］ ⇒ %値 ~LET 同じ行の “結果” の列に与える値

      %値 が満たす条件	%識別子	結果
      `Type$jA( %値 ) ~EQ `String$jT	`length^l	%値 の`長さ$str【！the number of elements in】に等しい `Number$jT 値
      `Array$jT である	`length^l	~NOABRUPT `ToLength$jA( ~NOABRUPT `Get$jA( %値, `length^l ) )
      `Blob$I である	`size^l	%値 の `size$mF に等しい `Number$jT 値
      `Blob$I である	`type^l	%値 の `type$mF に等しい `String$jT 値
      `File$I である	`name^l	%値 の `name$mF に等しい `String$jT 値
      `File$I である	`lastModified^l	%値 の `lastModified$mF に等しい `Number$jT 値

      【 `File^I であるならば `Blob^I でもあることに注意。 】

      ◎ If Type(value) is String, and identifier is "length" • Let value be a Number equal to the number of elements in value. ◎ If value is an Array and identifier is "length" • Let value be ! ToLength(! Get(value, "length")). ◎ If value is a Blob and identifier is "size" • Let value be a Number equal to value’s size. ◎ If value is a Blob and identifier is "type" • Let value be a String equal to value’s type. ◎ If value is a File and identifier is "name" • Let value be a String equal to value’s name. ◎ If value is a File and identifier is "lastModified" • Let value be a Number equal to value’s lastModified.

   2. ~ELSE： ◎ Otherwise

      1. ~IF［ `Type$jA( %値 ) ~NEQ `Object$jT ］ ⇒ ~RET `失敗^i ◎ If Type(value) is not Object, return failure.
      2. %hop ~LET ~NOABRUPT `HasOwnProperty$jA( %値, %識別子 ) ◎ Let hop be ! HasOwnProperty(value, identifier).
      3. ~IF［ %hop ~EQ `false^jv ］ ⇒ ~RET `失敗^i ◎ If hop is false, return failure.
      4. %値 ~LET ~NOABRUPT `Get$jA( %値, %識別子 ) ◎ Let value be ! Get(value, identifier).
      5. ~IF［ %値 ~EQ `undefined^jv ］ ⇒ ~RET `失敗^i ◎ If value is undefined, return failure.
5. ~Assert： %値 は`中途完了$でない ◎ Assert: value is not an abrupt completion.
6. ~RET %値 ◎ Return value.

注記： この~algoが適用される値は， `StructuredDeserialize$jA からの出力であり, “自前の” ~propのみに~accessするので、 上の手続きにおける ~Assert は満たされる。 ◎ NOTE: Assertions can be made in the above steps because this algorithm is only applied to values that are the output of StructuredDeserialize and only access "own" properties.

`~keyを値の中へ注入できるか検査する@ ~algoは、 所与の ( %値, %~key~path ) に対し，真偽値を返す： ◎ To check that a key could be injected into a value with value and a keyPath, run the following steps. The result of these steps is either true or false.

1. %識別子~list ~LET `区切子で厳密に分割する$( %~key~path, `002E^U (`.^l) ) ◎ Let identifiers be the result of strictly splitting keyPath on U+002E FULL STOP characters (.).
2. ~Assert： %識別子~list は空でない ◎ Assert: identifiers is not empty.
3. %識別子~list から最後の`~item$を`除去する$ ◎ Remove the last item of identifiers.

4. %識別子~list を成す ~EACH( %識別子 ) に対し： ◎ For each remaining identifier of identifiers, if any:

   1. ~IF［ %値 は［ `Object$jT, `Array$jT ］のいずれでもない ］ ⇒ ~RET ~F ◎ If value is not an Object or an Array, return false.
   2. %hop ~LET ~NOABRUPT `HasOwnProperty$jA( %値, %識別子 ) ◎ Let hop be ! HasOwnProperty(value, identifier).
   3. ~IF［ %hop ~EQ `false^jv ］ ⇒ ~RET ~T ◎ If hop is false, return true.
   4. %値 ~LET ~NOABRUPT `Get$jA( %値, %識別子 ) ◎ Let value be ! Get(value, identifier).
5. ~RET ~IS［ %値 は［ `Object$jT ／ `Array$jT ］である ］ ◎ Return true if value is an Object or an Array, or false otherwise.

注記： この~algoが適用される値は， `StructuredDeserialize$jA からの出力なので、 上の手続きにおける ~Assert は満たされる。 ◎ NOTE: Assertions can be made in the above steps because this algorithm is only applied to values that are the output of StructuredDeserialize.

`~keyを値の中へ注入する@ ~algoは、 所与の ( `値$ %値, `~key$ %~key, `~key~path$Os %~key~path ) に対し： ◎ To inject a key into a value using a key path with value, a key and a keyPath, run these steps:

1. %識別子~list ~LET `区切子で厳密に分割する$( %~key~path, `002E^U (`.^l) ) ◎ Let identifiers be the result of strictly splitting keyPath on U+002E FULL STOP characters (.).
2. ~Assert： %識別子~list は空でない ◎ Assert: identifiers is not empty.
3. %最後の識別子 ~LET %識別子~list の最後の`~item$ ◎ Let last be the last item of identifiers＼
4. %識別子~list から最後の`~item$を`除去する$ ◎ and remove it from the list.

5. %識別子~list を成す ~EACH( %識別子 ) に対し： ◎ For each remaining identifier of identifiers:

   1. ~Assert %値 は［ `Object$jT, `Array$jT ］のいずれかである ◎ Assert: value is an Object or an Array.
   2. %hop ~LET ~NOABRUPT `HasOwnProperty$jA( %値, %識別子 ) ◎ Let hop be ! HasOwnProperty(value, identifier).

   3. ~IF［ %hop ~EQ `false^jv ］： ◎ If hop is false, then:

      1. %o ~LET 式 `({})^jv で作成されるものと同じ，新たな `Object$jT ◎ Let o be a new Object created as if by the expression ({}).
      2. %状態s ~LET `CreateDataProperty$jA( %値, %識別子, %o ) ◎ Let status be CreateDataProperty(value, identifier, o).
      3. ~Assert： %状態s ~EQ `true^jv ◎ Assert: status is true.
   4. %値 ~LET ~NOABRUPT `Get$jA( %値, %識別子 ) ◎ Let value be ! Get(value, identifier).
6. ~Assert： %値 は `Object$jT または `Array$jT である ◎ Assert: value is an Object or an Array.
7. %~key値 ~LET `~keyを値に変換する$( %~key ) ◎ Let keyValue be the result of converting a key to a value with key.
8. %状態s ~LET `CreateDataProperty$jA( %値, %最後の識別子, %~key値 ) ◎ Let status be CreateDataProperty(value, last, keyValue).
9. ~Assert： %状態s ~EQ `true^jv ◎ Assert: status is true.

注記： この~algoが適用される値は、 `StructuredDeserialize$jA からの出力であり，`~keyを値の中へ注入できるか検査-$した後なので、 上の手続きにおける ~Assert は満たされる。 ◎ NOTE: Assertions can be made in the above steps because this algorithm is only applied to values that are the output of StructuredDeserialize, and the steps to check that a key could be injected into a value have been run.

`~keyを値に変換する@ ~algoは、 所与の ( `~key$ %~key ) に対し，~ES値を返す： ◎ To convert a key to a value with key, run the following steps. The steps return an ECMAScript value.

1. %値 ~LET %~key の`値$key ◎ Let type be key’s type. ◎ Let value be key’s value.

2. %~key の`型$keyに応じて： ◎ Switch on type:

   `number$i

   ~RET %値 に等しい~ES `Number$jT 値 ◎ Return an ECMAScript Number value equal to value

   `string$i

   ~RET %値 に等しい~ES `String$jT 値 ◎ Return an ECMAScript String value equal to value

   `date$i

   1. %日付 ~LET ~ES `Date$jT 構築子を ( %値 ) を引数に実行した結果 ◎ Let date be the result of executing the ECMAScript Date constructor with the single argument value.
   2. ~Assert： %日付 は`中途完了$でない ◎ Assert: date is not an abrupt completion.
   3. ~RET %日付 ◎ Return date.

   `binary$i

   1. %~buffer ~LET ~ES `ArrayBuffer$I 構築子を ( %値 の`長さ$byte ) を引数に実行した結果 ◎ Let len be value’s length. ◎ Let buffer be the result of executing the ECMAScript ArrayBuffer constructor with len.
   2. ~Assert： %~buffer は`中途完了$でない ◎ Assert: buffer is not an abrupt completion.
   3. %~buffer の `ArrayBufferData^sl 内部~slotの~entryたち ~SET %値 の~entryたち ◎ Set the entries in buffer’s [[ArrayBufferData]] internal slot to the entries in value.
   4. ~RET %~buffer ◎ Return buffer.

   `array$i

   1. %配列 ~LET ~ES `Array$jT 構築子を引数なしで実行した結果 ◎ Let array be the result of executing the ECMAScript Array constructor with no arguments.
   2. ~Assert： %配列 は`中途完了$でない ◎ Assert: array is not an abrupt completion.

   3. ~EACH( 整数 %~index ~IN { 0 〜 %値 の`~size$ ~MINUS 1 } ) に対し，昇順に： ◎ Let len be value’s size. ◎ Let index be 0. ◎ While index is less than len:

      1. %~entry ~LET `~keyを値に変換する$( %値[ %~index ] ) ◎ Let entry be the result of converting a key to a value with value[index].
      2. %状態s ~LET `CreateDataProperty$jA( %配列, %~index, %~entry ) ◎ Let status be CreateDataProperty(array, index, entry).
      3. ~Assert： %状態s ~EQ ~T ◎ Assert: status is true. ◎ Increase index by 1.
   4. ~RET %配列 ◎ Return array.

`値を~keyに変換する@ ~algoは、 所与の ( ~ES値 %入力, `集合$ %seen ) に対し，［ `~key$／`妥当でない^i ］を返すか例外を投出する： ◎ To convert a value to a key with an ECMAScript value input, and an optional set seen, run the following steps. The result of these steps is a key or invalid, or the steps may throw an exception.

【 %seen は［ %入力 が配列であるときに，自身を入子にしているかどうか検査する ］ために利用される。 】

1. ~IF［ %seen ~EQ ε ］ ⇒ %seen ~SET 新たな`集合$ ◎ If seen was not given, then let seen be a new empty set.
2. ~IF［ %入力 ~IN %seen ］ ⇒ ~RET `妥当でない^i ◎ If seen contains input, then return invalid.

3. ~IF［ `Type$jA( %入力 ) ~EQ `Number$jT ］： ◎ Jump to the appropriate step below: ◎ If Type(input) is Number

   1. ~IF［ %入力 ~EQ `NaN^jv ］ ⇒ ~RET `妥当でない^i ◎ If input is NaN then return invalid.
   2. ~RET 新たな`~key$ — その ⇒＃ `型$key ~SET `number$i, `値$key ~SET %入力 ◎ Otherwise, return a new key with type number and value input.

4. ~ELIF［ %入力 は `Date$jT ~objである （ `DateValue^sl 内部~slotを有する） ］： ◎ If input is a Date (has a [[DateValue]] internal slot)

   1. %ms ~LET %入力 の `DateValue^sl 内部~slotの値 ◎ Let ms be the value of input’s [[DateValue]] internal slot.
   2. ~IF［ %ms ~EQ `NaN^jv ］ ⇒ ~RET `妥当でない^i ◎ If ms is NaN then return invalid.
   3. ~RET 新たな`~key$ — その ⇒＃ `型$key ~SET `date$i, `値$key ~SET %ms ◎ Otherwise, return a new key with type date and value ms.

5. ~ELIF［ `Type$jA( %入力 ) ~EQ `String$jT ］ ⇒ ~RET 新たな`~key$ — その ⇒＃ `型$key ~SET `string$i, `値$key ~SET %入力 ◎ If Type(input) is String • Return a new key with type string and value input.

6. ~ELIF［ %入力 は`~buffer~source型$である ］ ◎ If input is a buffer source type

   1. ~IF［ %入力 は`切離されて$いる ］ ⇒ ~RET `妥当でない^i ◎ If input is [detached] then return invalid.
   2. %~byte列 ~LET %入力 に`保持された~byte列の複製を取得する$ — これは、 例外を投出し得る ◎ Let bytes be the result of getting a copy of the bytes held by the buffer source input. Rethrow any exceptions.
   3. ~RET 新たな`~key$ — その ⇒＃ `型$key ~SET `binary$i, `値$key ~SET %~byte列 ◎ Return a new key with type binary and value bytes.

7. ~ELIF［ %入力 は`~Array~exotic~obj$である ］： ◎ If input is an Array exotic object

   1. %長さ ~LET ~ABRUPT `ToLength$jA( ~ABRUPT `Get$jA( %入力, `length^l)) ◎ Let len be ? ToLength( ? Get(input, "length")).
   2. %seen に %入力 を`付加する$ ◎ Append input to seen.
   3. %~key群 ~LET 新たな`~list$ ◎ Let keys be a new empty list.

   4. ~EACH( 整数 %~index ~IN { 0 〜 %長さ ~MINUS 1 } ) に対し，昇順に： ◎ Let index be 0. ◎ While index is less than len:

      1. %hop ~LET ~ABRUPT `HasOwnProperty$jA( %入力, %~index ) ◎ Let hop be ? HasOwnProperty(input, index).
      2. ~IF［ %hop ~EQ `false^jv ］ ⇒ ~RET `妥当でない^i ◎ If hop is false, return invalid.
      3. %~entry ~LET ~ABRUPT `Get$jA( %入力, %~index ) ◎ Let entry be ? Get(input, index).
      4. %~key ~LET ~ABRUPT `値を~keyに変換する$( %~entry, %seen ) ◎ Let key be the result of converting a value to a key with arguments entry and seen. ◎ ReturnIfAbrupt(key).
      5. ~IF［ %~key ~EQ `妥当でない^i ］ ⇒ ~RET %~key ◎ If key is invalid abort these steps and return invalid.
      6. %~key群 に %~key を`付加する$ ◎ Append key to keys. ◎ Increase index by 1.
   5. ~RET 新たな`~key$ — その ⇒＃ `型$key ~SET `array$i, `値$key ~SET %~key群 ◎ Return a new array key with value keys.
8. ~RET `妥当でない^i ◎ Otherwise • Return invalid.

`配列を~key集合に変換する@ ~algoは、 所与の ( ~ES `Array$jT 値 %配列 ) に対し，`~key$たちが成す集合を返すか例外を投出する： ◎ To convert a value to a multiEntry key with an ECMAScript value input, run the following steps. The result of these steps is a key or invalid, or the steps may throw an exception. ◎ If input is an Array exotic object, then:

1. %長さ ~LET ~ABRUPT `ToLength$jA( ~ABRUPT `Get$jA( %配列, `length^l)) ◎ Let len be ? ToLength( ? Get(input, "length")).
2. %seen ~LET %配列 のみからなる新たな`集合$ ◎ Let seen be a new set containing only input.
3. %~key群 ~LET 新たな`集合$ ◎ Let keys be a new empty list.
4. %~index ~LET 0 ◎ Let index be 0.

5. ~WHILE ( %~index ~LT %長さ ) ： ◎ While index is less than len:

   1. %~entry ~LET `Get$jA( %配列, %~index ) ◎ Let entry be Get(input, index).

   2. ~IF［ %~entry は`中途完了$でない ］： ◎ If entry is not an abrupt completion, then:

      1. %~key ~LET `値を~keyに変換する$( %~entry, %seen ) ◎ Let key be the result of converting a value to a key with arguments entry and seen.
      2. ~IF［ %~key は`中途完了$でない ］~AND［ %~key ~NEQ `妥当でない^i ］~AND［ %~key ~NIN~cmpkey %~key群 ］ ⇒ %~key を %~key群 に`付加する$set ◎ If key is not invalid or an abrupt completion, and there is no item in keys equal to key, then append key to keys.
   3. %~index ~INCBY 1 ◎ Increase index by 1.
6. ~RET %~key群 ◎ Return a new array key with value set to keys.