@fireproof/vendor 0.0.0-smoke → 1.0.1

package/patched/@ipld/dag-json/test/test-basics.spec.js

@@ -1,290 +0,0 @@
-/* eslint-env mocha */
-import { garbage } from '@ipld/garbage'
-import { assert } from 'aegir/chai'
-import { bytes, CID } from 'multiformats'
-import { base64 } from 'multiformats/bases/base64'
-import { encode, decode, stringify, parse } from '../src/index.js'
-
-const same = assert.deepStrictEqual
-
-const recode = (/** @type {Uint8Array} */ byts) => encode(decode(byts))
-
-const link = CID.parse('bafyreifepiu23okq5zuyvyhsoiazv2icw2van3s7ko6d3ixl5jx2yj2yhu')
-
-describe('basic dag-json', () => {
-  it('encode decode', () => {
-    const byts = encode({ hello: 'world' })
-    same(JSON.parse(bytes.toString(recode(byts))), { hello: 'world' })
-    const o = { link, byts: bytes.fromString('asdf'), n: null, o: {} }
-    const byts2 = encode(o)
-    same(decode(byts2), o)
-    same(bytes.isBinary(decode(byts2).byts), true)
-  })
-
-  it('encode decode 2', () => {
-    // mirrors a go-ipld-prime test, but with sorted keys
-    const obj = { plain: 'olde string', bytes: utf8Encode('deadbeef') }
-    const expected = '{"bytes":{"/":{"bytes":"ZGVhZGJlZWY"}},"plain":"olde string"}'
-    const byts = encode(obj)
-    same(JSON.parse(bytes.toString(recode(byts))), JSON.parse(expected))
-    same(bytes.toString(recode(byts)), expected)
-  })
-
-  it('encode decode with ArrayBuffer', () => {
-    const byts = encode({ hello: 'world' })
-    same(JSON.parse(bytes.toString(recode(byts))), { hello: 'world' })
-    const o = { link, byts: bytes.fromString('asdf'), n: null, o: {} }
-    const byts2 = encode(o)
-    same(decode(byts2), o)
-    same(bytes.isBinary(decode(byts2).byts.buffer), true)
-  })
-
-  describe('reserved space', () => {
-    it('allow alternative types', () => {
-      //  wrong types
-      for (const obj of [true, false, null, 1, -1, 1.1, { blip: 'bop' }, ['foo']]) {
-        same(decode(encode({ '/': obj })), { '/': obj })
-        same(decode(encode({ '/': { bytes: obj } })), { '/': { bytes: obj } })
-      }
-    })
-
-    it('allow specials within reserved space', () => {
-      // can we put slash-objects within slashes?
-      same(decode(encode({ '/': bytes.fromString('asdf') })), { '/': bytes.fromString('asdf') })
-      same(new TextDecoder().decode(encode({ '/': bytes.fromString('asdf') })), '{"/":{"/":{"bytes":"YXNkZg"}}}')
-      same(decode(encode({ '/': link })), { '/': link })
-      same(new TextDecoder().decode(encode({ '/': link })), '{"/":{"/":"bafyreifepiu23okq5zuyvyhsoiazv2icw2van3s7ko6d3ixl5jx2yj2yhu"}}')
-    })
-
-    it('disallow extraneous tokens', () => {
-      // encode() shouldn't allow this but it currently does
-      // https://github.com/ipld/js-dag-json/issues/91 should change this test
-      // into two parts, encode and decode
-      assert.throws(() => decode(encode({ '/': link.toString(), x: 'bip' })))
-      assert.throws(() => decode(encode({ '/': { bytes: 'mS7ldeA', x: 'bip' } })))
-      assert.throws(() => decode(encode({ '/': { bytes: 'mS7ldeA' }, x: 'bip' })))
-      assert.throws(() => decode(encode({ '/': { bytes: 'mS7ldeA', x: 'bip' }, bop: 'bip' })))
-    })
-  })
-
-  it('native types', () => {
-    const flip = (/** @type {any} */ obj) => decode(encode(obj))
-    same(flip('test'), 'test')
-    same(flip(null), null)
-    same(flip(12), 12)
-    same(flip(-1), -1)
-    same(flip(1.2), 1.2)
-    same(flip(true), true)
-    same(flip(false), false)
-    same(flip([]), [])
-    same(flip(['asdf']), ['asdf'])
-    same(decode(utf8Encode('10.0')), 10)
-    same(decode(utf8Encode('[-10.0, 1.0, 0.0, 100.0]')), [-10, 1, 0, 100])
-  })
-
-  it('stable map key sorting', () => {
-    const s1 = bytes.toString(encode({ a: 1, b: 2, bb: 2.2, c: 3, c_: 3.3 }))
-    const s2 = bytes.toString(encode({ c_: 3.3, bb: 2.2, b: 2, c: 3, a: 1 }))
-    same('{"a":1,"b":2,"bb":2.2,"c":3,"c_":3.3}', s1)
-    same('{"a":1,"b":2,"bb":2.2,"c":3,"c_":3.3}', s2)
-  })
-
-  it('bigints', () => {
-    const verify = (/** @type {number | bigint} **/ inp) => {
-      assert.strictEqual(decode(utf8Encode(String(inp))), inp)
-    }
-
-    // plain Number objects
-    verify(0)
-    verify(1)
-    verify(-1)
-    verify(Math.pow(2, 50))
-    verify(-Math.pow(2, 50))
-    verify(Number.MAX_SAFE_INTEGER)
-    verify(-Number.MAX_SAFE_INTEGER)
-    // should round-trip as BigInts
-    verify(BigInt('9007199254740992')) // Number.MAX_SAFE_INTEGER+1
-    verify(BigInt('9007199254740993'))
-    verify(BigInt('11959030306112471731'))
-    verify(BigInt('18446744073709551615')) // max uint64
-    verify(BigInt('9223372036854775807')) // max int64
-    verify(BigInt('-9007199254740992'))
-    verify(BigInt('-9007199254740993'))
-    verify(BigInt('-9223372036854776000')) // min int64
-    verify(BigInt('-11959030306112471732'))
-    verify(BigInt('-18446744073709551616')) // min -uint64
-  })
-
-  it('error on circular references', () => {
-    const circularObj = {}
-    circularObj.a = circularObj
-    assert.throws(() => encode(circularObj), /object contains circular references/)
-    const circularArr = [circularObj]
-    circularObj.a = circularArr
-    assert.throws(() => encode(circularArr), /object contains circular references/)
-  })
-
-  it('error on encoding undefined', () => {
-    assert.throws(() => encode(undefined), /\Wundefined\W.*not supported/)
-    const objWithUndefined = { a: 'a', b: undefined }
-    assert.throws(() => encode(objWithUndefined), /\Wundefined\W.*not supported/)
-  })
-
-  it('error on encoding IEEE 754 specials', () => {
-    for (const special of [NaN, Infinity, -Infinity]) {
-      assert.throws(() => encode(special), new RegExp(`\\W${String(special)}\\W.*not supported`))
-      const objWithSpecial = { a: 'a', b: special }
-      assert.throws(() => encode(objWithSpecial), new RegExp(`\\W${String(special)}\\W.*not supported`))
-      const arrWithSpecial = [1, 1.1, -1, -1.1, Number.MAX_SAFE_INTEGER, special, Number.MIN_SAFE_INTEGER]
-      assert.throws(() => encode(arrWithSpecial), new RegExp(`\\W${String(special)}\\W.*not supported`))
-    }
-  })
-
-  it('fuzz serialize and deserialize with garbage', function () {
-    // filter out fuzz garbage for objects that are disqualified by DAG-JSON rules
-    /** @type {(obj: any) => boolean} */
-    const checkObj = (obj) => {
-      if (Array.isArray(obj)) {
-        return obj.every(checkObj)
-      }
-      if (obj && typeof obj === 'object') {
-        for (const [key, value] of Object.entries(obj)) {
-          if (key === '/') {
-            if (typeof value === 'string') {
-              return false
-            }
-            if (value && typeof value === 'object' && value.bytes !== undefined) {
-              return false
-            }
-          }
-          if (!checkObj(value)) {
-            return false
-          }
-        }
-      }
-      return true
-    }
-
-    this.timeout(5000)
-    for (let ii = 0; ii < 1000; ii++) {
-      const original = garbage(300)
-      if (!checkObj(original)) {
-        continue
-      }
-      const encoded = encode(original)
-      const decoded = decode(encoded)
-      same(decoded, original)
-    }
-  })
-
-  it('serialize', () => {
-    same(stringify({ hello: 'world' }), JSON.stringify({ hello: 'world' }))
-
-    const input = { link, bytes: bytes.fromString('asdf'), n: null, o: {} }
-    same(stringify(input), JSON.stringify({
-      bytes: { '/': { bytes: base64.baseEncode(input.bytes) } },
-      link: { '/': link.toString() },
-      n: null,
-      o: {}
-    }))
-
-    const output = parse(stringify(input))
-    same(input, output)
-    same(bytes.isBinary(output.bytes), true)
-    same(CID.asCID(output.link), output.link)
-  })
-
-  describe('typed arrays', () => {
-    // This mirrors what ships by default in dag-cbor: https://github.com/rvagg/cborg/blob/968fdac4af22c9b22fe5b40c2a6f9bb855780a4a/test/test-2bytes.js#L121
-    // It's an open question whether this should slip by without error or not,
-    // for now we silently convert them to plain bytes and they all round trip
-    // as Uint8Arrays.
-    const cases = /** @type {{obj: ArrayBufferView, expected: string}[]} */([
-      {
-        obj: Uint8Array.from([1, 2, 3]),
-        expected: '{"/":{"bytes":"AQID"}}'
-      },
-      {
-        obj: Uint8ClampedArray.from([1, 2, 3]),
-        expected: '{"/":{"bytes":"AQID"}}'
-      },
-      {
-        obj: Uint16Array.from([1, 2, 3]),
-        expected: '{"/":{"bytes":"AQACAAMA"}}'
-      },
-      {
-        obj: Uint32Array.from([1, 2, 3]),
-        expected: '{"/":{"bytes":"AQAAAAIAAAADAAAA"}}'
-      },
-      {
-        obj: Int8Array.from([1, 2, -3]),
-        expected: '{"/":{"bytes":"AQL9"}}'
-      },
-      {
-        obj: Int16Array.from([1, 2, -3]),
-        expected: '{"/":{"bytes":"AQACAP3/"}}'
-      },
-      {
-        obj: Int32Array.from([1, 2, -3]),
-        expected: '{"/":{"bytes":"AQAAAAIAAAD9////"}}'
-      },
-      {
-        obj: Float32Array.from([1, 2, -3]),
-        expected: '{"/":{"bytes":"AACAPwAAAEAAAEDA"}}'
-      },
-      {
-        obj: Float64Array.from([1, 2, -3]),
-        expected: '{"/":{"bytes":"AAAAAAAA8D8AAAAAAAAAQAAAAAAAAAjA"}}'
-      },
-      {
-        obj: BigUint64Array.from([BigInt(1), BigInt(2), BigInt(3)]),
-        expected: '{"/":{"bytes":"AQAAAAAAAAACAAAAAAAAAAMAAAAAAAAA"}}'
-      },
-      {
-        obj: BigInt64Array.from([BigInt(1), BigInt(2), BigInt(-3)]),
-        expected: '{"/":{"bytes":"AQAAAAAAAAACAAAAAAAAAP3/////////"}}'
-      },
-      {
-        obj: new DataView(Uint8Array.from([1, 2, 3]).buffer),
-        expected: '{"/":{"bytes":"AQID"}}'
-      },
-      {
-        obj: Uint8Array.from([1, 2, 3]).buffer,
-        expected: '{"/":{"bytes":"AQID"}}'
-      }
-    ])
-
-    for (const testCase of cases) {
-      it(testCase.obj.constructor.name, () => {
-        same(utf8Decode(encode(testCase.obj)), testCase.expected)
-        const decoded = decode(utf8Encode(testCase.expected))
-        assert.instanceOf(decoded, Uint8Array)
-        if (testCase.obj instanceof ArrayBuffer) {
-          same(decoded, new Uint8Array(testCase.obj))
-        } else {
-          same(decoded, new Uint8Array(testCase.obj.buffer, testCase.obj.byteOffset, testCase.obj.byteLength))
-        }
-      })
-    }
-  })
-
-  it('reject duplicate map keys', () => {
-    assert.throws(() => decode(utf8Encode('{"foo":1,"foo":2,"bar":3}')), /found repeat map key "foo"/)
-  })
-})
-
-/**
- * @param {string} s
- * @returns {Uint8Array}
- */
-function utf8Encode (s) {
-  return new TextEncoder().encode(s)
-}
-
-/**
- * @param {Uint8Array} b
- * @returns {string}
- */
-function utf8Decode (b) {
-  return new TextDecoder().decode(b)
-}

package/patched/@ipld/dag-json/test/ts-use/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "ts-use",
-  "private": true,
-  "dependencies": {
-    "@ipld/dag-json": "file:../../dist/",
-    "multiformats": "file:../../node_modules/multiformats"
-  },
-  "scripts": {
-    "test": "npm install && npx -p typescript tsc && node src/main.js"
-  }
-}

package/patched/@ipld/dag-json/test/ts-use/src/main.ts

@@ -1,54 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { BlockEncoder, BlockDecoder, BlockCodec } from 'multiformats/codecs/interface'
-import * as dagJson from '@ipld/dag-json'
-
-const main = () => {
-  // make sure we have a full CodecFeature
-  useCodecFeature(dagJson)
-}
-
-function useCodecFeature (codec: BlockCodec<297, any>) {
-  // use only as a BlockEncoder
-  useEncoder(codec)
-
-  // use only as a BlockDecoder
-  useDecoder(codec)
-
-  // use with ArrayBuffer input type
-  useDecoderWithArrayBuffer(codec)
-
-  // use as a full BlockCodec which does both BlockEncoder & BlockDecoder
-  useBlockCodec(codec)
-}
-
-function useEncoder<Codec extends number> (encoder: BlockEncoder<Codec, string>) {
-  deepStrictEqual(encoder.code, 297)
-  deepStrictEqual(encoder.name, 'dag-json')
-  deepStrictEqual(Array.from(encoder.encode('blip')), [34, 98, 108, 105, 112, 34])
-  console.log('[TS] ✓ { encoder: BlockEncoder }')
-}
-
-function useDecoder<Codec extends number> (decoder: BlockDecoder<Codec, Uint8Array>) {
-  deepStrictEqual(decoder.code, 297)
-  deepStrictEqual(decoder.decode(Uint8Array.from([34, 98, 108, 105, 112, 34 ])), 'blip')
-  console.log('[TS] ✓ { decoder: BlockDecoder }')
-}
-
-function useDecoderWithArrayBuffer<Codec extends number> (decoder: BlockDecoder<Codec, Uint8Array>) {
-  deepStrictEqual(decoder.code, 297)
-  deepStrictEqual(decoder.decode(Uint8Array.from([34, 98, 108, 105, 112, 34 ]).buffer), 'blip')
-  console.log('[TS] ✓ { decoder: BlockDecoder }')
-}
-
-function useBlockCodec<Codec extends number> (blockCodec: BlockCodec<Codec, string>) {
-  deepStrictEqual(blockCodec.code, 297)
-  deepStrictEqual(blockCodec.name, 'dag-json')
-  deepStrictEqual(Array.from(blockCodec.encode('blip')), [34, 98, 108, 105, 112, 34])
-  deepStrictEqual(blockCodec.decode(Uint8Array.from([34, 98, 108, 105, 112, 34])), 'blip')
-  console.log('[TS] ✓ {}:BlockCodec')
-}
-
-main()
-
-export default main

package/patched/@ipld/dag-json/test/ts-use/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "compilerOptions": {
-    "strict": true,
-    "moduleResolution": "node",
-    "noImplicitAny": true,
-    "skipLibCheck": false,
-    "incremental": true
-  }
-}

package/patched/@ipld/dag-json/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "extends": "aegir/src/config/tsconfig.aegir.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "emitDeclarationOnly": true
-  },
-  "include": [
-    "src",
-    "test"
-  ],
-  "exclude": [
-    "test/ts-use"
-  ]
-}

package/patched/cborg/example-json.js

@@ -1,6 +0,0 @@
-import { encode, decode } from 'cborg/json'
-
-const decoded = decode(Buffer.from('7b2274686973223a7b226973223a224a534f4e21222c22796179223a747275657d7d', 'hex'))
-console.log('decoded:', decoded)
-console.log('encoded:', encode(decoded))
-console.log('encoded (string):', Buffer.from(encode(decoded)).toString())

package/patched/cborg/example.js

@@ -1,5 +0,0 @@
-import { encode, decode } from 'cborg'
-
-const decoded = decode(Buffer.from('a16474686973a26269736543424f522163796179f5', 'hex'))
-console.log('decoded:', decoded)
-console.log('encoded:', encode(decoded))

package/patched/cborg/lib/0uint.js

@@ -1,227 +0,0 @@
-/* globals BigInt */
-
-import { Token, Type } from './token.js'
-import { decodeErrPrefix, assertEnoughData } from './common.js'
-
-export const uintBoundaries = [24, 256, 65536, 4294967296, BigInt('18446744073709551616')]
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} data
- * @param {number} offset
- * @param {DecodeOptions} options
- * @returns {number}
- */
-export function readUint8 (data, offset, options) {
-  assertEnoughData(data, offset, 1)
-  const value = data[offset]
-  if (options.strict === true && value < uintBoundaries[0]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
-  }
-  return value
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} offset
- * @param {DecodeOptions} options
- * @returns {number}
- */
-export function readUint16 (data, offset, options) {
-  assertEnoughData(data, offset, 2)
-  const value = (data[offset] << 8) | data[offset + 1]
-  if (options.strict === true && value < uintBoundaries[1]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
-  }
-  return value
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} offset
- * @param {DecodeOptions} options
- * @returns {number}
- */
-export function readUint32 (data, offset, options) {
-  assertEnoughData(data, offset, 4)
-  const value = (data[offset] * 16777216 /* 2 ** 24 */) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3]
-  if (options.strict === true && value < uintBoundaries[2]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
-  }
-  return value
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} offset
- * @param {DecodeOptions} options
- * @returns {number|bigint}
- */
-export function readUint64 (data, offset, options) {
-  // assume BigInt, convert back to Number if within safe range
-  assertEnoughData(data, offset, 8)
-  const hi = (data[offset] * 16777216 /* 2 ** 24 */) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3]
-  const lo = (data[offset + 4] * 16777216 /* 2 ** 24 */) + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7]
-  const value = (BigInt(hi) << BigInt(32)) + BigInt(lo)
-  if (options.strict === true && value < uintBoundaries[3]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
-  }
-  if (value <= Number.MAX_SAFE_INTEGER) {
-    return Number(value)
-  }
-  if (options.allowBigInt === true) {
-    return value
-  }
-  throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`)
-}
-
-/* not required thanks to quick[] list
-const oneByteTokens = new Array(24).fill(0).map((v, i) => new Token(Type.uint, i, 1))
-export function decodeUintCompact (data, pos, minor, options) {
-  return oneByteTokens[minor]
-}
-*/
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeUint8 (data, pos, _minor, options) {
-  return new Token(Type.uint, readUint8(data, pos + 1, options), 2)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeUint16 (data, pos, _minor, options) {
-  return new Token(Type.uint, readUint16(data, pos + 1, options), 3)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeUint32 (data, pos, _minor, options) {
-  return new Token(Type.uint, readUint32(data, pos + 1, options), 5)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeUint64 (data, pos, _minor, options) {
-  return new Token(Type.uint, readUint64(data, pos + 1, options), 9)
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- */
-export function encodeUint (buf, token) {
-  return encodeUintValue(buf, 0, token.value)
-}
-
-/**
- * @param {Bl} buf
- * @param {number} major
- * @param {number|bigint} uint
- */
-export function encodeUintValue (buf, major, uint) {
-  if (uint < uintBoundaries[0]) {
-    const nuint = Number(uint)
-    // pack into one byte, minor=0, additional=value
-    buf.push([major | nuint])
-  } else if (uint < uintBoundaries[1]) {
-    const nuint = Number(uint)
-    // pack into two byte, minor=0, additional=24
-    buf.push([major | 24, nuint])
-  } else if (uint < uintBoundaries[2]) {
-    const nuint = Number(uint)
-    // pack into three byte, minor=0, additional=25
-    buf.push([major | 25, nuint >>> 8, nuint & 0xff])
-  } else if (uint < uintBoundaries[3]) {
-    const nuint = Number(uint)
-    // pack into five byte, minor=0, additional=26
-    buf.push([major | 26, (nuint >>> 24) & 0xff, (nuint >>> 16) & 0xff, (nuint >>> 8) & 0xff, nuint & 0xff])
-  } else {
-    const buint = BigInt(uint)
-    if (buint < uintBoundaries[4]) {
-      // pack into nine byte, minor=0, additional=27
-      const set = [major | 27, 0, 0, 0, 0, 0, 0, 0]
-      // simulate bitwise above 32 bits
-      let lo = Number(buint & BigInt(0xffffffff))
-      let hi = Number(buint >> BigInt(32) & BigInt(0xffffffff))
-      set[8] = lo & 0xff
-      lo = lo >> 8
-      set[7] = lo & 0xff
-      lo = lo >> 8
-      set[6] = lo & 0xff
-      lo = lo >> 8
-      set[5] = lo & 0xff
-      set[4] = hi & 0xff
-      hi = hi >> 8
-      set[3] = hi & 0xff
-      hi = hi >> 8
-      set[2] = hi & 0xff
-      hi = hi >> 8
-      set[1] = hi & 0xff
-      buf.push(set)
-    } else {
-      throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`)
-    }
-  }
-}
-
-/**
- * @param {Token} token
- * @returns {number}
- */
-encodeUint.encodedSize = function encodedSize (token) {
-  return encodeUintValue.encodedSize(token.value)
-}
-
-/**
- * @param {number} uint
- * @returns {number}
- */
-encodeUintValue.encodedSize = function encodedSize (uint) {
-  if (uint < uintBoundaries[0]) {
-    return 1
-  }
-  if (uint < uintBoundaries[1]) {
-    return 2
-  }
-  if (uint < uintBoundaries[2]) {
-    return 3
-  }
-  if (uint < uintBoundaries[3]) {
-    return 5
-  }
-  return 9
-}
-
-/**
- * @param {Token} tok1
- * @param {Token} tok2
- * @returns {number}
- */
-encodeUint.compareTokens = function compareTokens (tok1, tok2) {
-  return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : /* c8 ignore next */ 0
-}