// Canonical structure records, their JSON readers and scalar accessors, and
// structure validation with canonical wire encoding and decoding.

import std.bytes { Bytes }
import std.json
import hash { 해시배열 }
import nodes { 노드종류 }
import util { 바이트로, 바이트배열로, 바이트추가, 배열같음, 부분배열 }
import wire {
  가변정수쓰기,
  가변정수읽기,
  널문자있음,
  사전색인,
  사전쓰기,
  사전읽기,
  사전해석,
  삼십이쓰기,
  삼십이읽기,
  안전문자열코드단위키,
  정렬고유,
  정수읽기,
  짝없는대리자있음,
  코드단위문자열,
  코드단위문자열만들기,
  코드단위사전쓰기,
  코드단위사전읽기,
  코드단위사전해석,
  코드단위키읽기,
}

export record 구조스칼라 {
  필드: string,
  태그: int,
  정수값: int,
  문자열값: string
}

export record 구조노드 {
  코드워드: int,
  부모순번: int,
  자식필드있음: bool,
  자식필드: string,
  자식색인: int,
  시작: int,
  끝: int,
  스칼라들: Array<구조스칼라>,
  식별자있음: bool,
  식별자류번호: int
}

export record 구조입력 {
  분리본문키해시: string,
  분리본문값수: int,
  노드들: Array<구조노드>
}

export record 이미지요청 {
  언어번호: int,
  팔레트번호: int,
  프로필해시: string,
  구조해시: string,
  키해시: string,
  크롬번호: int,
  제목: string,
  원본줄수: int,
  구조: 구조입력
}

// JSON readers. A record is read from JSON in the module that declares it, so
// the image request, which embeds a structure, is declared here as well.
export function 구조입력읽기(글: string) -> Result<구조입력, string> {
  json.parseAs<구조입력>(글)
}

export function 이미지요청읽기(글: string) -> Result<이미지요청, string> {
  json.parseAs<이미지요청>(글)
}

export function 구조언어번호(구조: 구조입력) -> int {
  if 구조.노드들.length == 0 { return 0 }
  let 뿌리코드 = 구조.노드들[0].코드워드
  if 노드종류(1, 뿌리코드) == 101 { return 1 }
  if 노드종류(2, 뿌리코드) == 101 { return 2 }
  if 노드종류(3, 뿌리코드) == 101 { return 3 }
  if 노드종류(4, 뿌리코드) == 101 { return 4 }
  if 노드종류(5, 뿌리코드) == 101 { return 5 }
  if 노드종류(6, 뿌리코드) == 101 { return 6 }
  if 노드종류(7, 뿌리코드) == 101 { return 7 }
  if 노드종류(8, 뿌리코드) == 101 { return 8 }
  if 노드종류(9, 뿌리코드) == 101 { return 9 }
  if 노드종류(10, 뿌리코드) == 101 { return 10 }
  if 노드종류(11, 뿌리코드) == 101 { return 11 }
  if 노드종류(12, 뿌리코드) == 101 { return 12 }
  if 노드종류(13, 뿌리코드) == 101 { return 13 }
  if 노드종류(14, 뿌리코드) == 101 { return 14 }
  if 노드종류(15, 뿌리코드) == 101 { return 15 }
  if 노드종류(16, 뿌리코드) == 101 { return 16 }
  if 노드종류(17, 뿌리코드) == 101 { return 17 }
  if 노드종류(18, 뿌리코드) == 101 { return 18 }
  if 노드종류(19, 뿌리코드) == 101 { return 19 }
  if 노드종류(21, 뿌리코드) == 101 { return 21 }
  if 노드종류(20, 뿌리코드) == 101 { return 20 }
  if 노드종류(22, 뿌리코드) == 101 { return 22 }
  if 노드종류(23, 뿌리코드) == 101 { return 23 }
  if 노드종류(24, 뿌리코드) == 101 { return 24 }
  if 노드종류(25, 뿌리코드) == 101 { return 25 }
  if 노드종류(26, 뿌리코드) == 101 { return 26 }
  if 노드종류(27, 뿌리코드) == 101 { return 27 }
  if 노드종류(28, 뿌리코드) == 101 { return 28 }
  if 노드종류(29, 뿌리코드) == 101 { return 29 }
  if 노드종류(30, 뿌리코드) == 101 { return 30 }
  0
}

function 코드단위태그허용(언어번호: int, 노드: 구조노드, 스칼라: 구조스칼라) -> bool {
  if 언어번호 != 1 && 언어번호 != 2 { return false }
  let 종류 = 노드종류(언어번호, 노드.코드워드)
  (종류 == 108 && 스칼라.필드 == "value") ||
    (종류 == 116 && 스칼라.필드 == "value.cooked")
}

function 구조스칼라검사(언어번호: int, 노드: 구조노드, 스칼라: 구조스칼라) -> Result<bool, string> {
  if 스칼라.필드 == "" || 널문자있음(스칼라.필드) {
    return Err("구조 스칼라 필드가 비었거나 영 문자를 포함합니다")
  }
  if 스칼라.필드 == "trailingFileLayout" {
    if 언어번호 != 12 || 노드.부모순번 != -1 || 노드.코드워드 != 36 ||
      스칼라.태그 != 5 || 스칼라.문자열값 == "" || 스칼라.문자열값.scalars().length > 4194304 {
      return Err("Swift 파일 끝 배치가 정규형이 아닙니다")
    }
    for 글자 in 스칼라.문자열값.scalars() {
      let 코드 = 글자.codePointAt(0) ?? 0
      if 코드 != 32 && !(코드 >= 9 && 코드 <= 13) {
        return Err("Swift 파일 끝 배치에 비배치 문자가 있습니다")
      }
    }
  }
  if 스칼라.태그 >= 0 && 스칼라.태그 <= 2 {
    if 스칼라.정수값 != 0 || 스칼라.문자열값 != "" {
      return Err("논리 구조 스칼라의 빈 본문이 정규형이 아닙니다")
    }
    return Ok(true)
  }
  if 스칼라.태그 == 3 {
    if 스칼라.정수값 < 0 || 스칼라.정수값 > 9007199254740991 || 스칼라.문자열값 != "" {
      return Err("양의 구조 스칼라가 안전 정수 정규형이 아닙니다")
    }
    return Ok(true)
  }
  if 스칼라.태그 == 4 {
    if 스칼라.정수값 < 1 || 스칼라.정수값 > 9007199254740991 || 스칼라.문자열값 != "" {
      return Err("음의 구조 스칼라가 안전 정수 정규형이 아닙니다")
    }
    return Ok(true)
  }
  if 스칼라.태그 == 5 {
    if 스칼라.정수값 != 0 { return Err("문자열 구조 스칼라 정수 본문이 0이 아닙니다") }
    return Ok(true)
  }
  if 스칼라.태그 == 6 {
    if 스칼라.정수값 != 0 { return Err("UTF-16 호스트 스칼라 정수 본문이 0이 아닙니다") }
    let 단위들 = 코드단위키읽기(스칼라.문자열값, false)?
    if !짝없는대리자있음(단위들) {
      return Err("UTF-16 호스트 스칼라에 짝없는 대리자가 없습니다")
    }
    if !코드단위태그허용(언어번호, 노드, 스칼라) {
      return Err("UTF-16 호스트 스칼라가 허용되지 않은 구조 위치에 있습니다")
    }
    return Ok(true)
  }
  Err("지원하지 않는 구조 스칼라 태그입니다")
}

export function 구조입력검사(언어번호: int, 구조: 구조입력) -> Result<bool, string> {
  for 노드 in 구조.노드들 {
    let mut 첫필드 = true
    let mut 이전필드 = ""
    for 스칼라 in 노드.스칼라들 {
      if !첫필드 && 이전필드 >= 스칼라.필드 { return Err("구조 스칼라 필드가 정규 순서가 아닙니다") }
      구조스칼라검사(언어번호, 노드, 스칼라)?
      이전필드 = 스칼라.필드
      첫필드 = false
    }
  }
  Ok(true)
}

function 구조스칼라코드단위문자열(스칼라: 구조스칼라) -> Result<코드단위문자열, string> {
  if 스칼라.태그 == 5 {
    let 키 = 안전문자열코드단위키(스칼라.문자열값)
    return Ok(코드단위문자열 { 키: 키, 안전값: 스칼라.문자열값, 안전: true })
  }
  if 스칼라.태그 == 6 { return 코드단위문자열만들기(스칼라.문자열값) }
  Err("문자열이 아닌 구조 스칼라입니다")
}

export record 압축원본행 {
  행: int,
  시작: int
}

function 원본기하필드인가(필드: string) -> bool {
  필드 == "startRow" || 필드 == "startColumn" ||
    필드 == "endRow" || 필드 == "endColumn"
}

function 압축원본행들(구조: 구조입력) -> Result<Array<압축원본행>, string> {
  let mut 행들: Array<압축원본행> = []
  for 노드 in 구조.노드들 {
    let mut 모서리 = 0
    while 모서리 < 2 {
      let 행필드 = if 모서리 == 0 { "startRow" } else { "endRow" }
      let 열필드 = if 모서리 == 0 { "startColumn" } else { "endColumn" }
      let 오프셋 = if 모서리 == 0 { 노드.시작 } else { 노드.끝 }
      let 행스칼라 = 노드스칼라(노드, 행필드)
      let 열스칼라 = 노드스칼라(노드, 열필드)
      if 행스칼라.태그 != 3 || 열스칼라.태그 != 3 ||
        행스칼라.정수값 < 0 || 열스칼라.정수값 < 0 || 열스칼라.정수값 > 오프셋 {
        return Err("JS/TS 원본 행 기하가 틀립니다")
      }
      let 행 = 행스칼라.정수값
      let 행시작 = 오프셋 - 열스칼라.정수값
      let mut 찾음 = false
      for 기존 in 행들 {
        if 기존.행 == 행 {
          if 기존.시작 != 행시작 { return Err("한 원본 행의 시작 오프셋이 서로 다릅니다") }
          찾음 = true
        }
      }
      if !찾음 { 행들.push(압축원본행 { 행: 행, 시작: 행시작 }) }
      모서리 = 모서리 + 1
    }
  }
  let mut 왼쪽 = 0
  while 왼쪽 < 행들.length {
    let mut 오른쪽 = 왼쪽 + 1
    while 오른쪽 < 행들.length {
      if 행들[오른쪽].행 < 행들[왼쪽].행 {
        let 임시 = 행들[왼쪽]
        행들[왼쪽] = 행들[오른쪽]
        행들[오른쪽] = 임시
      }
      오른쪽 = 오른쪽 + 1
    }
    왼쪽 = 왼쪽 + 1
  }
  let mut 색인 = 1
  while 색인 < 행들.length {
    if 행들[색인].시작 <= 행들[색인 - 1].시작 {
      return Err("원본 행 시작 오프셋이 엄격히 증가하지 않습니다")
    }
    색인 = 색인 + 1
  }
  Ok(행들)
}

function 압축원본문자위치(
  행들: Array<압축원본행>,
  오프셋: int
) -> Result<Array<int>, string> {
  let mut 아래 = -1
  let mut 위 = 행들.length
  while 아래 + 1 < 위 {
    let 가운데 = (아래 + 위) / 2
    if 행들[가운데].시작 <= 오프셋 { 아래 = 가운데 } else { 위 = 가운데 }
  }
  if 아래 < 0 { return Err("노드 오프셋이 첫 원본 행보다 앞섭니다") }
  Ok([행들[아래].행, 오프셋 - 행들[아래].시작])
}

function 구조스칼라필드정렬(값들: Array<구조스칼라>) -> Array<구조스칼라> {
  let mut 결과 = 값들
  let mut 왼쪽 = 0
  while 왼쪽 < 결과.length {
    let mut 오른쪽 = 왼쪽 + 1
    while 오른쪽 < 결과.length {
      if 결과[오른쪽].필드 < 결과[왼쪽].필드 {
        let 임시 = 결과[왼쪽]
        결과[왼쪽] = 결과[오른쪽]
        결과[오른쪽] = 임시
      }
      오른쪽 = 오른쪽 + 1
    }
    왼쪽 = 왼쪽 + 1
  }
  결과
}

function 구조인코드배열(구조: 구조입력) -> Result<Array<int>, string> {
  let 언어번호 = 구조언어번호(구조)
  let 압축기하 = 언어번호 == 1 || 언어번호 == 2
  구조입력검사(언어번호, 구조)?
  if 구조.분리본문키해시.scalars().length != 64 { return Err("분리 본문 키 해시 길이가 틀립니다") }
  let mut 자식모음: Array<string> = []
  let mut 스칼라필드모음: Array<string> = []
  let mut 스칼라문자키들: Array<string> = []
  for 노드 in 구조.노드들 {
    if 노드.자식필드있음 { 자식모음.push(노드.자식필드) }
    for 스칼라 in 노드.스칼라들 {
      if !압축기하 || !원본기하필드인가(스칼라.필드) {
        스칼라필드모음.push(스칼라.필드)
        if 스칼라.태그 == 5 || 스칼라.태그 == 6 {
          let 코드단위문자열 = 구조스칼라코드단위문자열(스칼라)?
          스칼라문자키들.push(코드단위문자열.키)
        }
      }
    }
  }
  let mut 원본행들: Array<압축원본행> = []
  if 압축기하 { 원본행들 = 압축원본행들(구조)? }
  let 자식사전 = 정렬고유(자식모음)
  let 스칼라필드사전 = 정렬고유(스칼라필드모음)
  let 스칼라문자사전 = 정렬고유(스칼라문자키들)
  let mut 내용 = 바이트배열로(Bytes.fromHex(구조.분리본문키해시)?)
  내용 = 가변정수쓰기(내용, 구조.노드들.length)
  내용 = 가변정수쓰기(내용, 구조.분리본문값수)
  if 압축기하 {
    내용 = 가변정수쓰기(내용, 원본행들.length)
    let mut 이전행 = -1
    let mut 이전시작 = 0
    for 행 in 원본행들 {
      내용 = 가변정수쓰기(내용, 행.행 - 이전행)
      내용 = 가변정수쓰기(내용, 행.시작 - 이전시작)
      이전행 = 행.행
      이전시작 = 행.시작
    }
  }
  내용 = 사전쓰기(내용, 자식사전)?
  내용 = 사전쓰기(내용, 스칼라필드사전)?
  내용 = 코드단위사전쓰기(내용, 스칼라문자사전)?
  let mut 순번 = 0
  let mut 스칼라문자순번 = 0
  for 노드 in 구조.노드들 {
    내용 = 가변정수쓰기(내용, 노드.코드워드)
    내용 = 가변정수쓰기(내용, if 노드.부모순번 < 0 { 0 } else { 순번 - 노드.부모순번 })
    내용 = 가변정수쓰기(내용, if 노드.자식필드있음 { 사전색인(자식사전, 노드.자식필드) + 1 } else { 0 })
    내용 = 가변정수쓰기(내용, if 노드.자식색인 < 0 { 0 } else { 노드.자식색인 + 1 })
    내용 = 가변정수쓰기(내용, 노드.시작)
    내용 = 가변정수쓰기(내용, 노드.끝)
    let mut 스칼라수 = 0
    for 스칼라 in 노드.스칼라들 {
      if !압축기하 || !원본기하필드인가(스칼라.필드) { 스칼라수 = 스칼라수 + 1 }
    }
    내용 = 가변정수쓰기(내용, 스칼라수)
    for 스칼라 in 노드.스칼라들 {
      if !압축기하 || !원본기하필드인가(스칼라.필드) {
        내용 = 가변정수쓰기(내용, 사전색인(스칼라필드사전, 스칼라.필드))
        내용.push(if 스칼라.태그 == 6 { 5 } else { 스칼라.태그 })
        if 스칼라.태그 == 3 || 스칼라.태그 == 4 { 내용 = 가변정수쓰기(내용, 스칼라.정수값) }
        else if 스칼라.태그 == 5 || 스칼라.태그 == 6 {
          if 스칼라문자순번 >= 스칼라문자키들.length {
            return Err("스칼라 문자열 키 캐시가 구조보다 짧습니다")
          }
          내용 = 가변정수쓰기(
            내용,
            사전색인(스칼라문자사전, 스칼라문자키들[스칼라문자순번])
          )
          스칼라문자순번 = 스칼라문자순번 + 1
        }
      }
    }
    if 노드.식별자있음 { 내용 = 가변정수쓰기(내용, 노드.식별자류번호) }
    순번 = 순번 + 1
  }
  if 스칼라문자순번 != 스칼라문자키들.length {
    return Err("스칼라 문자열 키 캐시가 구조보다 깁니다")
  }
  let 구조버전 = if 언어번호 == 1 || 언어번호 == 2 { 4 } else { 1 }
  let mut 본문 = [67, 73, 70, 83, 구조버전, 1, 0, 0]
  본문 = 삼십이쓰기(본문, 16 + 내용.length + 32)
  본문 = 삼십이쓰기(본문, 내용.length)
  본문 = 바이트추가(본문, 내용)
  let 결과 = 바이트추가(본문, 해시배열(본문))
  Ok(결과)
}

export function 구조인코드(입력: string) -> Result<Bytes, string> {
  let 구조 = json.parseAs<구조입력>(입력)?
  바이트로(구조인코드배열(구조)?)
}

export function 구조디코드(와이어: Bytes, 식별자표: Array<bool>) -> Result<string, string> {
  let 전체 = 바이트배열로(와이어)
  if 전체.length < 48 { return Err("구조 와이어가 잘렸습니다") }
  if 전체.length > 2097152 { return Err("구조 와이어가 허용량을 넘습니다") }
  let 본문 = 부분배열(전체, 0, 전체.length - 32)
  let 실제해시 = 부분배열(전체, 전체.length - 32, 전체.length)
  if !배열같음(실제해시, 해시배열(본문)) { return Err("구조 와이어 검사합이 맞지 않습니다") }
  if 본문[0] != 67 || 본문[1] != 73 || 본문[2] != 70 || 본문[3] != 83 { return Err("구조 와이어 마법값이 틀립니다") }
  if (본문[4] != 1 && 본문[4] != 4) || 본문[5] != 1 || 본문[6] != 0 || 본문[7] != 0 {
    return Err("구조 와이어 버전이 틀립니다")
  }
  let 와이어버전 = 본문[4]
  if 삼십이읽기(본문, 8) != 전체.length || 삼십이읽기(본문, 12) != 본문.length - 16 { return Err("구조 와이어 길이가 틀립니다") }
  let mut 위치 = 16
  let 해시끝 = 위치 + 32
  let 분리본문키바이트 = 바이트로(부분배열(본문, 위치, 해시끝))?
  let 분리본문키해시 = 분리본문키바이트.toHex()
  위치 = 해시끝
  let 노드수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 노드수읽기.다음
  let 본문수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 본문수읽기.다음
  if 식별자표.length != 노드수읽기.값 { return Err("식별자 표 길이가 노드 수와 다릅니다") }
  let mut 원본행들: Array<압축원본행> = []
  if 와이어버전 == 4 {
    let 행수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 행수읽기.다음
    if 행수읽기.값 == 0 || 행수읽기.값 > 노드수읽기.값 * 2 {
      return Err("원본 행 수가 허용량을 넘습니다")
    }
    let mut 이전행 = -1
    let mut 이전시작 = 0
    let mut 행색인 = 0
    while 행색인 < 행수읽기.값 {
      let 행차 = 가변정수읽기(본문, 위치)?; 위치 = 행차.다음
      let 시작차 = 가변정수읽기(본문, 위치)?; 위치 = 시작차.다음
      if 행차.값 == 0 || (행색인 > 0 && 시작차.값 == 0) {
        return Err("원본 행들이 엄격히 증가하지 않습니다")
      }
      let 행 = 이전행 + 행차.값
      let 시작 = 이전시작 + 시작차.값
      원본행들.push(압축원본행 { 행: 행, 시작: 시작 })
      이전행 = 행
      이전시작 = 시작
      행색인 = 행색인 + 1
    }
  }
  let 자식읽기 = 사전해석(본문, 위치)?; 위치 = 자식읽기.다음
  let 필드읽기 = 사전해석(본문, 위치)?; 위치 = 필드읽기.다음
  if 와이어버전 == 4 {
    for 필드 in 필드읽기.값들 {
      if 원본기하필드인가(필드) { return Err("원본 기하가 스칼라 사전에 중복되었습니다") }
    }
  }
  let 문자읽기 = 코드단위사전해석(본문, 위치)?; 위치 = 문자읽기.다음
  let mut 노드들: Array<구조노드> = []
  let mut 순번 = 0
  while 순번 < 노드수읽기.값 {
    let 코드 = 가변정수읽기(본문, 위치)?; 위치 = 코드.다음
    let 부모차 = 가변정수읽기(본문, 위치)?; 위치 = 부모차.다음
    let 자식필드코드 = 가변정수읽기(본문, 위치)?; 위치 = 자식필드코드.다음
    let 자식색인코드 = 가변정수읽기(본문, 위치)?; 위치 = 자식색인코드.다음
    let 시작읽기 = 가변정수읽기(본문, 위치)?; 위치 = 시작읽기.다음
    let 끝읽기 = 가변정수읽기(본문, 위치)?; 위치 = 끝읽기.다음
    let 스칼라수 = 가변정수읽기(본문, 위치)?; 위치 = 스칼라수.다음
    if 자식필드코드.값 > 자식읽기.값들.length { return Err("자식 필드 사전 색인이 틀립니다") }
    let mut 스칼라들: Array<구조스칼라> = []
    let mut 스칼라색인 = 0
    let mut 이전필드 = -1
    while 스칼라색인 < 스칼라수.값 {
      let 필드색인 = 가변정수읽기(본문, 위치)?; 위치 = 필드색인.다음
      if 필드색인.값 >= 필드읽기.값들.length || 필드색인.값 <= 이전필드 { return Err("스칼라 필드가 정규 순서가 아닙니다") }
      이전필드 = 필드색인.값
      if 위치 >= 본문.length { return Err("스칼라 태그가 잘렸습니다") }
      let 태그 = 본문[위치]; 위치 = 위치 + 1
      let mut 호스트태그 = 태그
      let mut 정수값 = 0
      let mut 문자열값 = ""
      if 태그 == 3 || 태그 == 4 {
        let 정수읽기값 = 가변정수읽기(본문, 위치)?; 위치 = 정수읽기값.다음
        정수값 = 정수읽기값.값
        if 태그 == 4 && 정수값 == 0 { return Err("음수 영은 허용되지 않습니다") }
      } else if 태그 == 5 {
        let 문자열색인 = 가변정수읽기(본문, 위치)?; 위치 = 문자열색인.다음
        if 문자열색인.값 >= 문자읽기.값들.length { return Err("스칼라 문자열 사전 색인이 틀립니다") }
        let 문자값 = 문자읽기.값들[문자열색인.값]
        if 문자값.안전 { 문자열값 = 문자값.안전값 }
        else { 호스트태그 = 6; 문자열값 = 문자값.키 }
      } else if 태그 < 0 || 태그 > 2 { return Err("스칼라 태그가 틀립니다") }
      스칼라들.push(구조스칼라 {
        필드: 필드읽기.값들[필드색인.값], 태그: 호스트태그,
        정수값: 정수값, 문자열값: 문자열값
      })
      스칼라색인 = 스칼라색인 + 1
    }
    if 와이어버전 == 4 {
      let 시작기하 = 압축원본문자위치(원본행들, 시작읽기.값)?
      let 끝기하 = 압축원본문자위치(원본행들, 끝읽기.값)?
      스칼라들.push(구조스칼라 { 필드: "startRow", 태그: 3, 정수값: 시작기하[0], 문자열값: "" })
      스칼라들.push(구조스칼라 { 필드: "startColumn", 태그: 3, 정수값: 시작기하[1], 문자열값: "" })
      스칼라들.push(구조스칼라 { 필드: "endRow", 태그: 3, 정수값: 끝기하[0], 문자열값: "" })
      스칼라들.push(구조스칼라 { 필드: "endColumn", 태그: 3, 정수값: 끝기하[1], 문자열값: "" })
      스칼라들 = 구조스칼라필드정렬(스칼라들)
    }
    let 식별자있음 = 식별자표[순번]
    let mut 식별자류번호 = 0
    if 식별자있음 {
      let 식별자읽기 = 가변정수읽기(본문, 위치)?; 위치 = 식별자읽기.다음
      식별자류번호 = 식별자읽기.값
    }
    노드들.push(구조노드 {
      코드워드: 코드.값,
      부모순번: if 순번 == 0 { -1 } else { 순번 - 부모차.값 },
      자식필드있음: 자식필드코드.값 != 0,
      자식필드: if 자식필드코드.값 == 0 { "" } else { 자식읽기.값들[자식필드코드.값 - 1] },
      자식색인: if 자식색인코드.값 == 0 { -1 } else { 자식색인코드.값 - 1 },
      시작: 시작읽기.값,
      끝: 끝읽기.값,
      스칼라들: 스칼라들,
      식별자있음: 식별자있음,
      식별자류번호: 식별자류번호
    })
    순번 = 순번 + 1
  }
  if 위치 != 본문.length { return Err("구조 와이어 뒤에 바이트가 남았습니다") }
  let 구조 = 구조입력 { 분리본문키해시: 분리본문키해시, 분리본문값수: 본문수읽기.값, 노드들: 노드들 }
  let 언어번호 = 구조언어번호(구조)
  let 예상버전 = if 언어번호 == 1 || 언어번호 == 2 { 4 } else { 1 }
  if 와이어버전 != 예상버전 { return Err("구조 와이어 버전이 언어와 맞지 않습니다") }
  구조입력검사(언어번호, 구조)?
  if !배열같음(구조인코드배열(구조)?, 전체) { return Err("구조 와이어가 정규 인코딩이 아닙니다") }
  json.stringify(구조)
}

export function 노드스칼라(노드: 구조노드, 필드: string) -> 구조스칼라 {
  for 스칼라 in 노드.스칼라들 { if 스칼라.필드 == 필드 { return 스칼라 } }
  구조스칼라 { 필드: "", 태그: 0, 정수값: 0, 문자열값: "" }
}

export function 스칼라있음(노드: 구조노드, 필드: string) -> bool { 노드스칼라(노드, 필드).필드 != "" }
export function 스칼라문자(노드: 구조노드, 필드: string) -> string { 노드스칼라(노드, 필드).문자열값 }
export function 스칼라논리(노드: 구조노드, 필드: string) -> bool { 노드스칼라(노드, 필드).태그 == 2 }
export function 스칼라정수(노드: 구조노드, 필드: string) -> int {
  let 값 = 노드스칼라(노드, 필드)
  if 값.태그 == 4 { -값.정수값 } else { 값.정수값 }
}
